SimGrid-3.11/000755 001750 001750 00000000000 12342443670 012031 5ustar00cici000000 000000 SimGrid-3.11/src/000755 001750 001750 00000000000 12342443653 012621 5ustar00cici000000 000000 SimGrid-3.11/src/instr/000755 001750 001750 00000000000 12342443651 013756 5ustar00cici000000 000000 SimGrid-3.11/src/instr/instr_trace.c000644 001750 001750 00000037755 12342443651 016460 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "instr/instr_private.h" #include "xbt/virtu.h" /* sg_cmdline */ #ifdef HAVE_TRACING XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_trace, instr, "tracing event system"); FILE *tracing_file = NULL; void print_NULL(paje_event_t event){} /* The active set of functions for the selected trace format * By default, they all do nothing, hence the print_NULL to avoid segfaults */ s_instr_trace_writer_t active_writer = { print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL, print_NULL }; xbt_dynar_t buffer = NULL; void dump_comment (const char *comment) { if (!strlen(comment)) return; fprintf (tracing_file, "# %s\n", comment); } void dump_comment_file (const char *filename) { if (!strlen(filename)) return; FILE *file = fopen (filename, "r"); if (!file){ THROWF (system_error, 1, "Comment file %s could not be opened for reading.", filename); } while (!feof(file)){ char c; c = fgetc(file); if (feof(file)) break; fprintf (tracing_file, "# "); while (c != '\n'){ fprintf (tracing_file, "%c", c); c = fgetc(file); if (feof(file)) break; } fprintf (tracing_file, "\n"); } fclose(file); } void TRACE_init() { buffer = xbt_dynar_new(sizeof(paje_event_t), NULL); } void TRACE_finalize() { xbt_dynar_free(&buffer); } double TRACE_last_timestamp_to_dump = 0; //dumps the trace file until the timestamp TRACE_last_timestamp_to_dump void TRACE_paje_dump_buffer (int force) { if (!TRACE_is_enabled()) return; XBT_DEBUG("%s: dump until %f. starts", __FUNCTION__, TRACE_last_timestamp_to_dump); if (force){ paje_event_t event; unsigned int i; xbt_dynar_foreach(buffer, i, event){ event->print (event); event->free (event); } xbt_dynar_free (&buffer); buffer = xbt_dynar_new (sizeof(paje_event_t), NULL); }else{ paje_event_t event; unsigned int cursor; xbt_dynar_foreach(buffer, cursor, event) { double head_timestamp = event->timestamp; if (head_timestamp > TRACE_last_timestamp_to_dump){ break; } event->print (event); event->free (event); } xbt_dynar_remove_n_at(buffer, cursor, 0); } XBT_DEBUG("%s: ends", __FUNCTION__); } /* internal do the instrumentation module */ static void insert_into_buffer (paje_event_t tbi) { if (TRACE_buffer() == 0){ tbi->print (tbi); tbi->free (tbi); return; } XBT_DEBUG("%s: insert event_type=%d, timestamp=%f, buffersize=%lu)", __FUNCTION__, (int)tbi->event_type, tbi->timestamp, xbt_dynar_length(buffer)); unsigned int i; for (i = xbt_dynar_length(buffer); i > 0; i--) { paje_event_t e1 = *(paje_event_t*)xbt_dynar_get_ptr(buffer, i - 1); if (e1->timestamp <= tbi->timestamp) break; } xbt_dynar_insert_at(buffer, i, &tbi); if (i == 0) XBT_DEBUG("%s: inserted at beginning", __FUNCTION__); else XBT_DEBUG("%s: inserted at%s %u", __FUNCTION__, (i == xbt_dynar_length(buffer) - 1 ? " end, pos =" : ""), i); } static void free_paje_event (paje_event_t event) { XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); switch (event->event_type){ case PAJE_StartLink: xbt_free (((startLink_t)(event->data))->value); xbt_free (((startLink_t)(event->data))->key); break; case PAJE_EndLink: xbt_free (((endLink_t)(event->data))->value); xbt_free (((endLink_t)(event->data))->key); break; default: break; } xbt_free (event->data); xbt_free (event); } void new_pajeDefineContainerType(type_t type) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_DefineContainerType; event->timestamp = 0; event->print = active_writer.print_DefineContainerType; event->free = free_paje_event; event->data = xbt_new0(s_defineContainerType_t, 1); ((defineContainerType_t)(event->data))->type = type; XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type); //print it event->print (event); event->free (event); } void new_pajeDefineVariableType(type_t type) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_DefineVariableType; event->timestamp = 0; event->print = active_writer.print_DefineVariableType; event->free = free_paje_event; event->data = xbt_new0(s_defineVariableType_t, 1); ((defineVariableType_t)(event->data))->type = type; XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type); //print it event->print (event); event->free (event); } void new_pajeDefineStateType(type_t type) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_DefineStateType; event->timestamp = 0; event->print = active_writer.print_DefineStateType; event->free = free_paje_event; event->data = xbt_new0(s_defineStateType_t, 1); ((defineStateType_t)(event->data))->type = type; XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type); //print it event->print (event); event->free (event); } void new_pajeDefineEventType(type_t type) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_DefineEventType; event->timestamp = 0; event->print = active_writer.print_DefineEventType; event->free = free_paje_event; event->data = xbt_new0(s_defineEventType_t, 1); ((defineEventType_t)(event->data))->type = type; XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type); //print it event->print (event); event->free (event); } void new_pajeDefineLinkType(type_t type, type_t source, type_t dest) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_DefineLinkType; event->timestamp = 0; event->print = active_writer.print_DefineLinkType; event->free = free_paje_event; event->data = xbt_new0(s_defineLinkType_t, 1); ((defineLinkType_t)(event->data))->type = type; ((defineLinkType_t)(event->data))->source = source; ((defineLinkType_t)(event->data))->dest = dest; XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type); //print it event->print (event); event->free (event); } void new_pajeDefineEntityValue (val_t value) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_DefineEntityValue; event->timestamp = 0; event->print = active_writer.print_DefineEntityValue; event->free = free_paje_event; event->data = xbt_new0(s_defineEntityValue_t, 1); ((defineEntityValue_t)(event->data))->value = value; XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type); //print it event->print (event); event->free (event); } void new_pajeCreateContainer (container_t container) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_CreateContainer; event->timestamp = SIMIX_get_clock(); event->print = active_writer.print_CreateContainer; event->free = free_paje_event; event->data = xbt_new0(s_createContainer_t, 1); ((createContainer_t)(event->data))->container = container; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); //print it event->print (event); event->free (event); } void new_pajeDestroyContainer (container_t container) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_DestroyContainer; event->timestamp = SIMIX_get_clock(); event->print = active_writer.print_DestroyContainer; event->free = free_paje_event; event->data = xbt_new0(s_destroyContainer_t, 1); ((destroyContainer_t)(event->data))->container = container; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); //print it event->print (event); event->free (event); } void new_pajeSetVariable (double timestamp, container_t container, type_t type, double value) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_SetVariable; event->timestamp = timestamp; event->print = active_writer.print_SetVariable; event->free = free_paje_event; event->data = xbt_new0(s_setVariable_t, 1); ((setVariable_t)(event->data))->type = type; ((setVariable_t)(event->data))->container = container; ((setVariable_t)(event->data))->value = value; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); insert_into_buffer (event); } void new_pajeAddVariable (double timestamp, container_t container, type_t type, double value) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_AddVariable; event->timestamp = timestamp; event->print = active_writer.print_AddVariable; event->free = free_paje_event; event->data = xbt_new0(s_addVariable_t, 1); ((addVariable_t)(event->data))->type = type; ((addVariable_t)(event->data))->container = container; ((addVariable_t)(event->data))->value = value; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); insert_into_buffer (event); } void new_pajeSubVariable (double timestamp, container_t container, type_t type, double value) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_SubVariable; event->timestamp = timestamp; event->print = active_writer.print_SubVariable; event->free = free_paje_event; event->data = xbt_new0(s_subVariable_t, 1); ((subVariable_t)(event->data))->type = type; ((subVariable_t)(event->data))->container = container; ((subVariable_t)(event->data))->value = value; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); insert_into_buffer (event); } void new_pajeSetState (double timestamp, container_t container, type_t type, val_t value) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_SetState; event->timestamp = timestamp; event->print = active_writer.print_SetState; event->free = free_paje_event; event->data = xbt_new0(s_setState_t, 1); ((setState_t)(event->data))->type = type; ((setState_t)(event->data))->container = container; ((setState_t)(event->data))->value = value; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); insert_into_buffer (event); } void new_pajePushStateWithExtra (double timestamp, container_t container, type_t type, val_t value, void* extra) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_PushState; event->timestamp = timestamp; event->print = active_writer.print_PushState; event->free = free_paje_event; event->data = xbt_new0(s_pushState_t, 1); ((pushState_t)(event->data))->type = type; ((pushState_t)(event->data))->container = container; ((pushState_t)(event->data))->value = value; ((pushState_t)(event->data))->extra = extra; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); insert_into_buffer (event); } void new_pajePushState (double timestamp, container_t container, type_t type, val_t value) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_PushState; event->timestamp = timestamp; event->print = active_writer.print_PushState; event->free = free_paje_event; event->data = xbt_new0(s_pushState_t, 1); ((pushState_t)(event->data))->type = type; ((pushState_t)(event->data))->container = container; ((pushState_t)(event->data))->value = value; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); insert_into_buffer (event); } void new_pajePopState (double timestamp, container_t container, type_t type) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_PopState; event->timestamp = timestamp; event->print = active_writer.print_PopState; event->free = free_paje_event; event->data = xbt_new0(s_popState_t, 1); ((popState_t)(event->data))->type = type; ((popState_t)(event->data))->container = container; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); insert_into_buffer (event); } void new_pajeResetState (double timestamp, container_t container, type_t type) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_ResetState; event->timestamp = timestamp; event->print = active_writer.print_ResetState; event->free = free_paje_event; event->data = xbt_new0(s_resetState_t, 1); ((resetState_t)(event->data))->type = type; ((resetState_t)(event->data))->container = container; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); insert_into_buffer (event); } void new_pajeStartLink (double timestamp, container_t container, type_t type, container_t sourceContainer, const char *value, const char *key) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_StartLink; event->timestamp = timestamp; event->print = active_writer.print_StartLink; event->free = free_paje_event; event->data = xbt_new0(s_startLink_t, 1); ((startLink_t)(event->data))->type = type; ((startLink_t)(event->data))->container = container; ((startLink_t)(event->data))->sourceContainer = sourceContainer; ((startLink_t)(event->data))->value = xbt_strdup(value); ((startLink_t)(event->data))->key = xbt_strdup(key); ((startLink_t)(event->data))->size = -1; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); insert_into_buffer (event); } void new_pajeStartLinkWithSize (double timestamp, container_t container, type_t type, container_t sourceContainer, const char *value, const char *key, int size) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_StartLink; event->timestamp = timestamp; event->print = active_writer.print_StartLink; event->free = free_paje_event; event->data = xbt_new0(s_startLink_t, 1); ((startLink_t)(event->data))->type = type; ((startLink_t)(event->data))->container = container; ((startLink_t)(event->data))->sourceContainer = sourceContainer; ((startLink_t)(event->data))->value = xbt_strdup(value); ((startLink_t)(event->data))->key = xbt_strdup(key); ((startLink_t)(event->data))->size = size; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); insert_into_buffer (event); } void new_pajeEndLink (double timestamp, container_t container, type_t type, container_t destContainer, const char *value, const char *key) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_EndLink; event->timestamp = timestamp; event->print = active_writer.print_EndLink; event->free = free_paje_event; event->data = xbt_new0(s_endLink_t, 1); ((endLink_t)(event->data))->type = type; ((endLink_t)(event->data))->container = container; ((endLink_t)(event->data))->destContainer = destContainer; ((endLink_t)(event->data))->value = xbt_strdup(value); ((endLink_t)(event->data))->key = xbt_strdup(key); XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); insert_into_buffer (event); } void new_pajeNewEvent (double timestamp, container_t container, type_t type, val_t value) { paje_event_t event = xbt_new0(s_paje_event_t, 1); event->event_type = PAJE_NewEvent; event->timestamp = timestamp; event->print = active_writer.print_NewEvent; event->free = free_paje_event; event->data = xbt_new0(s_newEvent_t, 1); ((newEvent_t)(event->data))->type = type; ((newEvent_t)(event->data))->container = container; ((newEvent_t)(event->data))->value = value; XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); insert_into_buffer (event); } #endif /* HAVE_TRACING */ SimGrid-3.11/src/instr/instr_interface.c000644 001750 001750 00000127416 12342443651 017314 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "simgrid_config.h" #ifdef HAVE_TRACING #include "instr/instr_private.h" #include "surf/surf.h" #include "surf/surf_private.h" typedef enum { INSTR_US_DECLARE, INSTR_US_SET, INSTR_US_ADD, INSTR_US_SUB } InstrUserVariable; XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_api, instr, "API"); xbt_dict_t created_categories = NULL; xbt_dict_t declared_marks = NULL; xbt_dict_t user_host_variables = NULL; xbt_dict_t user_vm_variables = NULL; xbt_dict_t user_link_variables = NULL; extern xbt_dict_t trivaNodeTypes; extern xbt_dict_t trivaEdgeTypes; static xbt_dynar_t instr_dict_to_dynar (xbt_dict_t filter) { if (!TRACE_is_enabled()) return NULL; if (!TRACE_needs_platform()) return NULL; xbt_dynar_t ret = xbt_dynar_new (sizeof(char*), &xbt_free_ref); xbt_dict_cursor_t cursor = NULL; char *name, *value; xbt_dict_foreach(filter, cursor, name, value) { xbt_dynar_push_as (ret, char*, xbt_strdup(name)); } return ret; } /** \ingroup TRACE_category * \brief Declare a new category with a random color. * * This function should be used to define a user category. The * category can be used to differentiate the tasks that are created * during the simulation (for example, tasks from server1, server2, * or request tasks, computation tasks, communication tasks). All * resource utilization (host power and link bandwidth) will be * classified according to the task category. Tasks that do not * belong to a category are not traced. The color for the category * that is being declared is random. This function has no effect * if a category with the same name has been already declared. * * See \ref tracing for details on how to trace * the (categorized) resource utilization. * * \param category The name of the new tracing category to be created. * * \see TRACE_category_with_color, MSG_task_set_category, SD_task_set_category */ void TRACE_category(const char *category) { TRACE_category_with_color (category, NULL); } /** \ingroup TRACE_category * \brief Declare a new category with a color. * * Same as #TRACE_category, but let user specify a color encoded as a * RGB-like string with three floats from 0 to 1. So, to specify a * red color, pass "1 0 0" as color parameter. A light-gray color * can be specified using "0.7 0.7 0.7" as color. This function has * no effect if a category with the same name has been already declared. * * See \ref tracing for details on how to trace * the (categorized) resource utilization. * * \param category The name of the new tracing category to be created. * \param color The color of the category (see \ref tracing to * know how to correctly specify the color) * * \see MSG_task_set_category, SD_task_set_category */ void TRACE_category_with_color (const char *category, const char *color) { /* safe switch */ if (!TRACE_is_enabled()) return; if (!(TRACE_categorized() && category != NULL)) return; /* if platform is not traced, we can't deal with categories */ if (!TRACE_needs_platform()) return; //check if category is already created char *created = xbt_dict_get_or_null(created_categories, category); if (created) return; xbt_dict_set (created_categories, category, xbt_strdup("1"), NULL); //define final_color char final_color[INSTR_DEFAULT_STR_SIZE]; if (!color){ //generate a random color double red = drand48(); double green = drand48(); double blue = drand48(); snprintf (final_color, INSTR_DEFAULT_STR_SIZE, "%f %f %f", red, green, blue); }else{ snprintf (final_color, INSTR_DEFAULT_STR_SIZE, "%s", color); } XBT_DEBUG("CAT,declare %s, \"%s\" \"%s\"", category, color, final_color); //define the type of this category on top of hosts and links instr_new_variable_type (category, final_color); } /** \ingroup TRACE_category * \brief Get declared categories * * This function should be used to get categories that were already * declared with #TRACE_category or with #TRACE_category_with_color. * * See \ref tracing for details on how to trace * the (categorized) resource utilization. * * \return A dynar with the declared categories, must be freed with xbt_dynar_free. * * \see MSG_task_set_category, SD_task_set_category */ xbt_dynar_t TRACE_get_categories (void) { if (!TRACE_is_enabled()) return NULL; if (!TRACE_categorized()) return NULL; return instr_dict_to_dynar (created_categories); } /** \ingroup TRACE_mark * \brief Declare a new type for tracing mark. * * This function declares a new Paje event * type in the trace file that can be used by * simulators to declare application-level * marks. This function is independent of * which API is used in SimGrid. * * \param mark_type The name of the new type. * * \see TRACE_mark */ void TRACE_declare_mark(const char *mark_type) { /* safe switch */ if (!TRACE_is_enabled()) return; /* if platform is not traced, we don't allow marks */ if (!TRACE_needs_platform()) return; if (!mark_type) THROWF (tracing_error, 1, "mark_type is NULL"); //check if mark_type is already declared char *created = xbt_dict_get_or_null(declared_marks, mark_type); if (created) { THROWF (tracing_error, 1, "mark_type with name (%s) is already declared", mark_type); } XBT_DEBUG("MARK,declare %s", mark_type); PJ_type_event_new(mark_type, PJ_type_get_root()); xbt_dict_set (declared_marks, mark_type, xbt_strdup("1"), NULL); } /** \ingroup TRACE_mark * \brief Declare a new colored value for a previously declared mark type. * * This function declares a new colored value for a Paje event * type in the trace file that can be used by * simulators to declare application-level * marks. This function is independent of * which API is used in SimGrid. The color needs to be * a string with three numbers separated by spaces in the range [0,1]. * A light-gray color can be specified using "0.7 0.7 0.7" as color. * If a NULL color is provided, the color used will be white ("1 1 1"). * * \param mark_type The name of the new type. * \param mark_value The name of the new value for this type. * \param mark_color The color of the new value for this type. * * \see TRACE_mark */ void TRACE_declare_mark_value_with_color (const char *mark_type, const char *mark_value, const char *mark_color) { /* safe switch */ if (!TRACE_is_enabled()) return; /* if platform is not traced, we don't allow marks */ if (!TRACE_needs_platform()) return; if (!mark_type) THROWF (tracing_error, 1, "mark_type is NULL"); if (!mark_value) THROWF (tracing_error, 1, "mark_value is NULL"); type_t type = PJ_type_get (mark_type, PJ_type_get_root()); if (!type){ THROWF (tracing_error, 1, "mark_type with name (%s) is not declared", mark_type); } char white[INSTR_DEFAULT_STR_SIZE] = "1.0 1.0 1.0"; if (!mark_color) mark_color = white; XBT_DEBUG("MARK,declare_value %s %s %s", mark_type, mark_value, mark_color); PJ_value_new (mark_value, mark_color, type); } /** \ingroup TRACE_mark * \brief Declare a new value for a previously declared mark type. * * This function declares a new value for a Paje event * type in the trace file that can be used by * simulators to declare application-level * marks. This function is independent of * which API is used in SimGrid. Calling this function is the same * as calling \ref TRACE_declare_mark_value_with_color with a NULL color. * * \param mark_type The name of the new type. * \param mark_value The name of the new value for this type. * * \see TRACE_mark */ void TRACE_declare_mark_value (const char *mark_type, const char *mark_value) { TRACE_declare_mark_value_with_color (mark_type, mark_value, NULL); } /** * \ingroup TRACE_mark * \brief Create a new instance of a tracing mark type. * * This function creates a mark in the trace file. The * first parameter had to be previously declared using * #TRACE_declare_mark, the second is the identifier * for this mark instance. We recommend that the * mark_value is a unique value for the whole simulation. * Nevertheless, this is not a strong requirement: the * trace will be valid even if there are multiple mark * identifiers for the same trace. * * \param mark_type The name of the type for which the new instance will belong. * \param mark_value The name of the new instance mark. * * \see TRACE_declare_mark */ void TRACE_mark(const char *mark_type, const char *mark_value) { /* safe switch */ if (!TRACE_is_enabled()) return; /* if platform is not traced, we don't allow marks */ if (!TRACE_needs_platform()) return; if (!mark_type) THROWF (tracing_error, 1, "mark_type is NULL"); if (!mark_value) THROWF (tracing_error, 1, "mark_value is NULL"); //check if mark_type is already declared type_t type = PJ_type_get (mark_type, PJ_type_get_root()); if (!type){ THROWF (tracing_error, 1, "mark_type with name (%s) is not declared", mark_type); } val_t value = PJ_value_get (mark_value, type); XBT_DEBUG("MARK %s %s", mark_type, mark_value); new_pajeNewEvent (MSG_get_clock(), PJ_container_get_root(), type, value); } /** \ingroup TRACE_mark * \brief Get declared marks * * This function should be used to get marks that were already * declared with #TRACE_declare_mark. * * \return A dynar with the declared marks, must be freed with xbt_dynar_free. * */ xbt_dynar_t TRACE_get_marks (void) { if (!TRACE_is_enabled()) return NULL; return instr_dict_to_dynar (declared_marks); } static void instr_user_variable(double time, const char *resource, const char *variable, const char *father_type, double value, InstrUserVariable what, const char *color, xbt_dict_t filter) { /* safe switch */ if (!TRACE_is_enabled()) return; /* if platform is not traced, we don't allow user variables */ if (!TRACE_needs_platform()) return; //check if variable is already declared char *created = xbt_dict_get_or_null(filter, variable); if (what == INSTR_US_DECLARE){ if (created){ //already declared return; }else{ xbt_dict_set (filter, variable, xbt_strdup("1"), NULL); } }else{ if (!created){ //not declared, ignore return; } } char valuestr[100]; snprintf(valuestr, 100, "%g", value); switch (what){ case INSTR_US_DECLARE: instr_new_user_variable_type (father_type, variable, color); break; case INSTR_US_SET: { container_t container = PJ_container_get(resource); type_t type = PJ_type_get (variable, container->type); new_pajeSetVariable(time, container, type, value); break; } case INSTR_US_ADD: { container_t container = PJ_container_get(resource); type_t type = PJ_type_get (variable, container->type); new_pajeAddVariable(time, container, type, value); break; } case INSTR_US_SUB: { container_t container = PJ_container_get(resource); type_t type = PJ_type_get (variable, container->type); new_pajeSubVariable(time, container, type, value); break; } default: //TODO: launch exception break; } } static void instr_user_srcdst_variable(double time, const char *src, const char *dst, const char *variable, const char *father_type, double value, InstrUserVariable what) { xbt_dynar_t route=NULL; sg_routing_edge_t src_elm = sg_routing_edge_by_name_or_null(src); if(!src_elm) xbt_die("Element '%s' not found!",src); sg_routing_edge_t dst_elm = sg_routing_edge_by_name_or_null(dst); if(!dst_elm) xbt_die("Element '%s' not found!",dst); routing_get_route_and_latency (src_elm, dst_elm, &route,NULL); unsigned int i; void *link; xbt_dynar_foreach (route, i, link) { char *link_name = (char*)surf_resource_name(link); instr_user_variable (time, link_name, variable, father_type, value, what, NULL, user_link_variables); } } /** \ingroup TRACE_API * \brief Creates a file with the topology of the platform file used for the simulator. * * The graph topology will have the following properties: all hosts, links and routers * of the platform file are mapped to graph nodes; routes are mapped to edges. * The platform's AS are not represented in the output. * * \param filename The name of the file that will hold the graph. * * \return 1 of successful, 0 otherwise. */ int TRACE_platform_graph_export_graphviz (const char *filename) { /* returns 1 if successful, 0 otherwise */ if (!TRACE_is_enabled()) return 0; xbt_graph_t g = instr_routing_platform_graph(); if (g == NULL) return 0; instr_routing_platform_graph_export_graphviz (g, filename); xbt_graph_free_graph (g, xbt_free, xbt_free, NULL); return 1; } /* * Derived functions that use instr_user_variable and TRACE_user_srcdst_variable. * They were previously defined as pre-processors directives, but were transformed * into functions so the user can track them using gdb. */ /* for VM variables */ /** \ingroup TRACE_user_variables * \brief Declare a new user variable associated to VMs. * * Declare a user variable that will be associated to VMs. * A user vm variable can be used to trace user variables * such as the number of tasks in a VM, the number of * clients in an application (for VMs), and so on. The color * associated to this new variable will be random. * * \param variable The name of the new variable to be declared. * * \see TRACE_vm_variable_declare_with_color */ void TRACE_vm_variable_declare (const char *variable) { instr_user_variable(0, NULL, variable, "MSG_VM", 0, INSTR_US_DECLARE, NULL, user_vm_variables); } /** \ingroup TRACE_user_variables * \brief Declare a new user variable associated to VMs with a color. * * Same as #TRACE_vm_variable_declare, but associated a color * to the newly created user host variable. The color needs to be * a string with three numbers separated by spaces in the range [0,1]. * A light-gray color can be specified using "0.7 0.7 0.7" as color. * * \param variable The name of the new variable to be declared. * \param color The color for the new variable. * */ void TRACE_vm_variable_declare_with_color (const char *variable, const char *color) { instr_user_variable(0, NULL, variable, "MSG_VM", 0, INSTR_US_DECLARE, color, user_vm_variables); } /** \ingroup TRACE_user_variables * \brief Set the value of a variable of a host. * * \param vm The name of the VM to be considered. * \param variable The name of the variable to be considered. * \param value The new value of the variable. * * \see TRACE_vm_variable_declare, TRACE_vm_variable_add, TRACE_vm_variable_sub */ void TRACE_vm_variable_set (const char *vm, const char *variable, double value) { TRACE_vm_variable_set_with_time (MSG_get_clock(), vm, variable, value); } /** \ingroup TRACE_user_variables * \brief Add a value to a variable of a VM. * * \param vm The name of the VM to be considered. * \param variable The name of the variable to be considered. * \param value The value to be added to the variable. * * \see TRACE_vm_variable_declare, TRACE_vm_variable_set, TRACE_vm_variable_sub */ void TRACE_vm_variable_add (const char *vm, const char *variable, double value) { TRACE_vm_variable_add_with_time (MSG_get_clock(), vm, variable, value); } /** \ingroup TRACE_user_variables * \brief Subtract a value from a variable of a VM. * * \param vm The name of the vm to be considered. * \param variable The name of the variable to be considered. * \param value The value to be subtracted from the variable. * * \see TRACE_vm_variable_declare, TRACE_vm_variable_set, TRACE_vm_variable_add */ void TRACE_vm_variable_sub (const char *vm, const char *variable, double value) { TRACE_vm_variable_sub_with_time (MSG_get_clock(), vm, variable, value); } /** \ingroup TRACE_user_variables * \brief Set the value of a variable of a VM at a given timestamp. * * Same as #TRACE_vm_variable_set, but let user specify * the time used to trace it. Users can specify a time that * is not the simulated clock time as defined by the core * simulator. This allows a fine-grain control of time * definition, but should be used with caution since the trace * can be inconsistent if resource utilization traces are also traced. * * \param time The timestamp to be used to tag this change of value. * \param vm The name of the VM to be considered. * \param variable The name of the variable to be considered. * \param value The new value of the variable. * * \see TRACE_vm_variable_declare, TRACE_vm_variable_add_with_time, TRACE_vm_variable_sub_with_time */ void TRACE_vm_variable_set_with_time (double time, const char *vm, const char *variable, double value) { instr_user_variable(time, vm, variable, "MSG_VM", value, INSTR_US_SET, NULL, user_vm_variables); } /** \ingroup TRACE_user_variables * \brief Add a value to a variable of a VM at a given timestamp. * * Same as #TRACE_vm_variable_add, but let user specify * the time used to trace it. Users can specify a time that * is not the simulated clock time as defined by the core * simulator. This allows a fine-grain control of time * definition, but should be used with caution since the trace * can be inconsistent if resource utilization traces are also traced. * * \param time The timestamp to be used to tag this change of value. * \param vm The name of the VM to be considered. * \param variable The name of the variable to be considered. * \param value The value to be added to the variable. * * \see TRACE_vm_variable_declare, TRACE_vm_variable_set_with_time, TRACE_vm_variable_sub_with_time */ void TRACE_vm_variable_add_with_time (double time, const char *vm, const char *variable, double value) { instr_user_variable(time, vm, variable, "MSG_VM", value, INSTR_US_ADD, NULL, user_vm_variables); } /** \ingroup TRACE_user_variables * \brief Subtract a value from a variable of a VM at a given timestamp. * * Same as #TRACE_vm_variable_sub, but let user specify * the time used to trace it. Users can specify a time that * is not the simulated clock time as defined by the core * simulator. This allows a fine-grain control of time * definition, but should be used with caution since the trace * can be inconsistent if resource utilization traces are also traced. * * \param time The timestamp to be used to tag this change of value. * \param vm The name of the VM to be considered. * \param variable The name of the variable to be considered. * \param value The value to be subtracted from the variable. * * \see TRACE_vm_variable_declare, TRACE_vm_variable_set_with_time, TRACE_vm_variable_add_with_time */ void TRACE_vm_variable_sub_with_time (double time, const char *vm, const char *variable, double value) { instr_user_variable(time, vm, variable, "MSG_VM", value, INSTR_US_SUB, NULL, user_vm_variables); } /** \ingroup TRACE_user_variables * \brief Get declared user vm variables * * This function should be used to get VM variables that were already * declared with #TRACE_vm_variable_declare or with #TRACE_vm_variable_declare_with_color. * * \return A dynar with the declared host variables, must be freed with xbt_dynar_free. */ xbt_dynar_t TRACE_get_vm_variables (void) { return instr_dict_to_dynar (user_vm_variables); } /* for host variables */ /** \ingroup TRACE_user_variables * \brief Declare a new user variable associated to hosts. * * Declare a user variable that will be associated to hosts. * A user host variable can be used to trace user variables * such as the number of tasks in a server, the number of * clients in an application (for hosts), and so on. The color * associated to this new variable will be random. * * \param variable The name of the new variable to be declared. * * \see TRACE_host_variable_declare_with_color */ void TRACE_host_variable_declare (const char *variable) { instr_user_variable(0, NULL, variable, "HOST", 0, INSTR_US_DECLARE, NULL, user_host_variables); } /** \ingroup TRACE_user_variables * \brief Declare a new user variable associated to hosts with a color. * * Same as #TRACE_host_variable_declare, but associated a color * to the newly created user host variable. The color needs to be * a string with three numbers separated by spaces in the range [0,1]. * A light-gray color can be specified using "0.7 0.7 0.7" as color. * * \param variable The name of the new variable to be declared. * \param color The color for the new variable. * */ void TRACE_host_variable_declare_with_color (const char *variable, const char *color) { instr_user_variable(0, NULL, variable, "HOST", 0, INSTR_US_DECLARE, color, user_host_variables); } /** \ingroup TRACE_user_variables * \brief Set the value of a variable of a host. * * \param host The name of the host to be considered. * \param variable The name of the variable to be considered. * \param value The new value of the variable. * * \see TRACE_host_variable_declare, TRACE_host_variable_add, TRACE_host_variable_sub */ void TRACE_host_variable_set (const char *host, const char *variable, double value) { TRACE_host_variable_set_with_time (MSG_get_clock(), host, variable, value); } /** \ingroup TRACE_user_variables * \brief Add a value to a variable of a host. * * \param host The name of the host to be considered. * \param variable The name of the variable to be considered. * \param value The value to be added to the variable. * * \see TRACE_host_variable_declare, TRACE_host_variable_set, TRACE_host_variable_sub */ void TRACE_host_variable_add (const char *host, const char *variable, double value) { TRACE_host_variable_add_with_time (MSG_get_clock(), host, variable, value); } /** \ingroup TRACE_user_variables * \brief Subtract a value from a variable of a host. * * \param host The name of the host to be considered. * \param variable The name of the variable to be considered. * \param value The value to be subtracted from the variable. * * \see TRACE_host_variable_declare, TRACE_host_variable_set, TRACE_host_variable_add */ void TRACE_host_variable_sub (const char *host, const char *variable, double value) { TRACE_host_variable_sub_with_time (MSG_get_clock(), host, variable, value); } /** \ingroup TRACE_user_variables * \brief Set the value of a variable of a host at a given timestamp. * * Same as #TRACE_host_variable_set, but let user specify * the time used to trace it. Users can specify a time that * is not the simulated clock time as defined by the core * simulator. This allows a fine-grain control of time * definition, but should be used with caution since the trace * can be inconsistent if resource utilization traces are also traced. * * \param time The timestamp to be used to tag this change of value. * \param host The name of the host to be considered. * \param variable The name of the variable to be considered. * \param value The new value of the variable. * * \see TRACE_host_variable_declare, TRACE_host_variable_add_with_time, TRACE_host_variable_sub_with_time */ void TRACE_host_variable_set_with_time (double time, const char *host, const char *variable, double value) { instr_user_variable(time, host, variable, "HOST", value, INSTR_US_SET, NULL, user_host_variables); } /** \ingroup TRACE_user_variables * \brief Add a value to a variable of a host at a given timestamp. * * Same as #TRACE_host_variable_add, but let user specify * the time used to trace it. Users can specify a time that * is not the simulated clock time as defined by the core * simulator. This allows a fine-grain control of time * definition, but should be used with caution since the trace * can be inconsistent if resource utilization traces are also traced. * * \param time The timestamp to be used to tag this change of value. * \param host The name of the host to be considered. * \param variable The name of the variable to be considered. * \param value The value to be added to the variable. * * \see TRACE_host_variable_declare, TRACE_host_variable_set_with_time, TRACE_host_variable_sub_with_time */ void TRACE_host_variable_add_with_time (double time, const char *host, const char *variable, double value) { instr_user_variable(time, host, variable, "HOST", value, INSTR_US_ADD, NULL, user_host_variables); } /** \ingroup TRACE_user_variables * \brief Subtract a value from a variable of a host at a given timestamp. * * Same as #TRACE_host_variable_sub, but let user specify * the time used to trace it. Users can specify a time that * is not the simulated clock time as defined by the core * simulator. This allows a fine-grain control of time * definition, but should be used with caution since the trace * can be inconsistent if resource utilization traces are also traced. * * \param time The timestamp to be used to tag this change of value. * \param host The name of the host to be considered. * \param variable The name of the variable to be considered. * \param value The value to be subtracted from the variable. * * \see TRACE_host_variable_declare, TRACE_host_variable_set_with_time, TRACE_host_variable_add_with_time */ void TRACE_host_variable_sub_with_time (double time, const char *host, const char *variable, double value) { instr_user_variable(time, host, variable, "HOST", value, INSTR_US_SUB, NULL, user_host_variables); } /** \ingroup TRACE_user_variables * \brief Get declared user host variables * * This function should be used to get host variables that were already * declared with #TRACE_host_variable_declare or with #TRACE_host_variable_declare_with_color. * * \return A dynar with the declared host variables, must be freed with xbt_dynar_free. */ xbt_dynar_t TRACE_get_host_variables (void) { return instr_dict_to_dynar (user_host_variables); } /* for link variables */ /** \ingroup TRACE_user_variables * \brief Declare a new user variable associated to links. * * Declare a user variable that will be associated to links. * A user link variable can be used, for example, to trace * user variables such as the number of messages being * transferred through network links. The color * associated to this new variable will be random. * * \param variable The name of the new variable to be declared. * * \see TRACE_link_variable_declare_with_color */ void TRACE_link_variable_declare (const char *variable) { instr_user_variable (0, NULL, variable, "LINK", 0, INSTR_US_DECLARE, NULL, user_link_variables); } /** \ingroup TRACE_user_variables * \brief Declare a new user variable associated to links with a color. * * Same as #TRACE_link_variable_declare, but associated a color * to the newly created user link variable. The color needs to be * a string with three numbers separated by spaces in the range [0,1]. * A light-gray color can be specified using "0.7 0.7 0.7" as color. * * \param variable The name of the new variable to be declared. * \param color The color for the new variable. * */ void TRACE_link_variable_declare_with_color (const char *variable, const char *color) { instr_user_variable (0, NULL, variable, "LINK", 0, INSTR_US_DECLARE, color, user_link_variables); } /** \ingroup TRACE_user_variables * \brief Set the value of a variable of a link. * * \param link The name of the link to be considered. * \param variable The name of the variable to be considered. * \param value The new value of the variable. * * \see TRACE_link_variable_declare, TRACE_link_variable_add, TRACE_link_variable_sub */ void TRACE_link_variable_set (const char *link, const char *variable, double value) { TRACE_link_variable_set_with_time (MSG_get_clock(), link, variable, value); } /** \ingroup TRACE_user_variables * \brief Add a value to a variable of a link. * * \param link The name of the link to be considered. * \param variable The name of the variable to be considered. * \param value The value to be added to the variable. * * \see TRACE_link_variable_declare, TRACE_link_variable_set, TRACE_link_variable_sub */ void TRACE_link_variable_add (const char *link, const char *variable, double value) { TRACE_link_variable_add_with_time (MSG_get_clock(), link, variable, value); } /** \ingroup TRACE_user_variables * \brief Subtract a value from a variable of a link. * * \param link The name of the link to be considered. * \param variable The name of the variable to be considered. * \param value The value to be subtracted from the variable. * * \see TRACE_link_variable_declare, TRACE_link_variable_set, TRACE_link_variable_add */ void TRACE_link_variable_sub (const char *link, const char *variable, double value) { TRACE_link_variable_sub_with_time (MSG_get_clock(), link, variable, value); } /** \ingroup TRACE_user_variables * \brief Set the value of a variable of a link at a given timestamp. * * Same as #TRACE_link_variable_set, but let user specify * the time used to trace it. Users can specify a time that * is not the simulated clock time as defined by the core * simulator. This allows a fine-grain control of time * definition, but should be used with caution since the trace * can be inconsistent if resource utilization traces are also traced. * * \param time The timestamp to be used to tag this change of value. * \param link The name of the link to be considered. * \param variable The name of the variable to be considered. * \param value The new value of the variable. * * \see TRACE_link_variable_declare, TRACE_link_variable_add_with_time, TRACE_link_variable_sub_with_time */ void TRACE_link_variable_set_with_time (double time, const char *link, const char *variable, double value) { instr_user_variable (time, link, variable, "LINK", value, INSTR_US_SET, NULL, user_link_variables); } /** \ingroup TRACE_user_variables * \brief Add a value to a variable of a link at a given timestamp. * * Same as #TRACE_link_variable_add, but let user specify * the time used to trace it. Users can specify a time that * is not the simulated clock time as defined by the core * simulator. This allows a fine-grain control of time * definition, but should be used with caution since the trace * can be inconsistent if resource utilization traces are also traced. * * \param time The timestamp to be used to tag this change of value. * \param link The name of the link to be considered. * \param variable The name of the variable to be considered. * \param value The value to be added to the variable. * * \see TRACE_link_variable_declare, TRACE_link_variable_set_with_time, TRACE_link_variable_sub_with_time */ void TRACE_link_variable_add_with_time (double time, const char *link, const char *variable, double value) { instr_user_variable (time, link, variable, "LINK", value, INSTR_US_ADD, NULL, user_link_variables); } /** \ingroup TRACE_user_variables * \brief Subtract a value from a variable of a link at a given timestamp. * * Same as #TRACE_link_variable_sub, but let user specify * the time used to trace it. Users can specify a time that * is not the simulated clock time as defined by the core * simulator. This allows a fine-grain control of time * definition, but should be used with caution since the trace * can be inconsistent if resource utilization traces are also traced. * * \param time The timestamp to be used to tag this change of value. * \param link The name of the link to be considered. * \param variable The name of the variable to be considered. * \param value The value to be subtracted from the variable. * * \see TRACE_link_variable_declare, TRACE_link_variable_set_with_time, TRACE_link_variable_add_with_time */ void TRACE_link_variable_sub_with_time (double time, const char *link, const char *variable, double value) { instr_user_variable (time, link, variable, "LINK", value, INSTR_US_SUB, NULL, user_link_variables); } /* for link variables, but with src and dst used for get_route */ /** \ingroup TRACE_user_variables * \brief Set the value of the variable present in the links connecting source and destination. * * Same as #TRACE_link_variable_set, but instead of providing the * name of link to be considered, provide the source and destination * hosts. All links that are part of the route between source and * destination will have the variable set to the provided value. * * \param src The name of the source host for get route. * \param dst The name of the destination host for get route. * \param variable The name of the variable to be considered. * \param value The new value of the variable. * * \see TRACE_link_variable_declare, TRACE_link_srcdst_variable_add, TRACE_link_srcdst_variable_sub */ void TRACE_link_srcdst_variable_set (const char *src, const char *dst, const char *variable, double value) { TRACE_link_srcdst_variable_set_with_time (MSG_get_clock(), src, dst, variable, value); } /** \ingroup TRACE_user_variables * \brief Add a value to the variable present in the links connecting source and destination. * * Same as #TRACE_link_variable_add, but instead of providing the * name of link to be considered, provide the source and destination * hosts. All links that are part of the route between source and * destination will have the value passed as parameter added to * the current value of the variable name to be considered. * * \param src The name of the source host for get route. * \param dst The name of the destination host for get route. * \param variable The name of the variable to be considered. * \param value The value to be added to the variable. * * \see TRACE_link_variable_declare, TRACE_link_srcdst_variable_set, TRACE_link_srcdst_variable_sub */ void TRACE_link_srcdst_variable_add (const char *src, const char *dst, const char *variable, double value) { TRACE_link_srcdst_variable_add_with_time (MSG_get_clock(), src, dst, variable, value); } /** \ingroup TRACE_user_variables * \brief Subtract a value from the variable present in the links connecting source and destination. * * Same as #TRACE_link_variable_sub, but instead of providing the * name of link to be considered, provide the source and destination * hosts. All links that are part of the route between source and * destination will have the value passed as parameter subtracted from * the current value of the variable name to be considered. * * \param src The name of the source host for get route. * \param dst The name of the destination host for get route. * \param variable The name of the variable to be considered. * \param value The value to be subtracted from the variable. * * \see TRACE_link_variable_declare, TRACE_link_srcdst_variable_set, TRACE_link_srcdst_variable_add */ void TRACE_link_srcdst_variable_sub (const char *src, const char *dst, const char *variable, double value) { TRACE_link_srcdst_variable_sub_with_time (MSG_get_clock(), src, dst, variable, value); } /** \ingroup TRACE_user_variables * \brief Set the value of the variable present in the links connecting source and destination at a given timestamp. * * Same as #TRACE_link_srcdst_variable_set, but let user specify * the time used to trace it. Users can specify a time that * is not the simulated clock time as defined by the core * simulator. This allows a fine-grain control of time * definition, but should be used with caution since the trace * can be inconsistent if resource utilization traces are also traced. * * \param time The timestamp to be used to tag this change of value. * \param src The name of the source host for get route. * \param dst The name of the destination host for get route. * \param variable The name of the variable to be considered. * \param value The new value of the variable. * * \see TRACE_link_variable_declare, TRACE_link_srcdst_variable_add_with_time, TRACE_link_srcdst_variable_sub_with_time */ void TRACE_link_srcdst_variable_set_with_time (double time, const char *src, const char *dst, const char *variable, double value) { instr_user_srcdst_variable (time, src, dst, variable, "LINK", value, INSTR_US_SET); } /** \ingroup TRACE_user_variables * \brief Add a value to the variable present in the links connecting source and destination at a given timestamp. * * Same as #TRACE_link_srcdst_variable_add, but let user specify * the time used to trace it. Users can specify a time that * is not the simulated clock time as defined by the core * simulator. This allows a fine-grain control of time * definition, but should be used with caution since the trace * can be inconsistent if resource utilization traces are also traced. * * \param time The timestamp to be used to tag this change of value. * \param src The name of the source host for get route. * \param dst The name of the destination host for get route. * \param variable The name of the variable to be considered. * \param value The value to be added to the variable. * * \see TRACE_link_variable_declare, TRACE_link_srcdst_variable_set_with_time, TRACE_link_srcdst_variable_sub_with_time */ void TRACE_link_srcdst_variable_add_with_time (double time, const char *src, const char *dst, const char *variable, double value) { instr_user_srcdst_variable (time, src, dst, variable, "LINK", value, INSTR_US_ADD); } /** \ingroup TRACE_user_variables * \brief Subtract a value from the variable present in the links connecting source and destination at a given timestamp. * * Same as #TRACE_link_srcdst_variable_sub, but let user specify * the time used to trace it. Users can specify a time that * is not the simulated clock time as defined by the core * simulator. This allows a fine-grain control of time * definition, but should be used with caution since the trace * can be inconsistent if resource utilization traces are also traced. * * \param time The timestamp to be used to tag this change of value. * \param src The name of the source host for get route. * \param dst The name of the destination host for get route. * \param variable The name of the variable to be considered. * \param value The value to be subtracted from the variable. * * \see TRACE_link_variable_declare, TRACE_link_srcdst_variable_set_with_time, TRACE_link_srcdst_variable_add_with_time */ void TRACE_link_srcdst_variable_sub_with_time (double time, const char *src, const char *dst, const char *variable, double value) { instr_user_srcdst_variable (time, src, dst, variable, "LINK", value, INSTR_US_SUB); } /** \ingroup TRACE_user_variables * \brief Get declared user link variables * * This function should be used to get link variables that were already * declared with #TRACE_link_variable_declare or with #TRACE_link_variable_declare_with_color. * * \return A dynar with the declared link variables, must be freed with xbt_dynar_free. */ xbt_dynar_t TRACE_get_link_variables (void) { return instr_dict_to_dynar (user_link_variables); } /** \ingroup TRACE_user_variables * \brief Declare a new user state associated to hosts. * * Declare a user state that will be associated to hosts. * A user host state can be used to trace application states. * * \param state The name of the new state to be declared. * * \see TRACE_host_state_declare_value */ void TRACE_host_state_declare (const char *state) { instr_new_user_state_type("HOST", state); } /** \ingroup TRACE_user_variables * \brief Declare a new value for a user state associated to hosts. * * Declare a value for a state. The color needs to be * a string with three numbers separated by spaces in the range [0,1]. * A light-gray color can be specified using "0.7 0.7 0.7" as color. * * \param state The name of the new state to be declared. * \param value The name of the value * \param color The color of the value * * \see TRACE_host_state_declare */ void TRACE_host_state_declare_value (const char *state, const char *value, const char *color) { instr_new_value_for_user_state_type (state, value, color); } /** \ingroup TRACE_user_variables * \brief Set the user state to the given value. * * Change a user state previously declared to the given value. * * \param host The name of the host to be considered. * \param state The name of the state previously declared. * \param value The new value of the state. * * \see TRACE_host_state_declare, TRACE_host_push_state, TRACE_host_pop_state, TRACE_host_reset_state */ void TRACE_host_set_state (const char *host, const char *state, const char *value) { container_t container = PJ_container_get(host); type_t type = PJ_type_get (state, container->type); val_t val = PJ_value_get_or_new (value, NULL, type); /* if user didn't declare a value with a color, user a NULL color */ new_pajeSetState(MSG_get_clock(), container, type, val); } /** \ingroup TRACE_user_variables * \brief Push a new value for a state of a given host. * * Change a user state previously declared by pushing the new value to the state. * * \param host The name of the host to be considered. * \param state The name of the state previously declared. * \param value The value to be pushed. * * \see TRACE_host_state_declare, TRACE_host_set_state, TRACE_host_pop_state, TRACE_host_reset_state */ void TRACE_host_push_state (const char *host, const char *state, const char *value) { container_t container = PJ_container_get(host); type_t type = PJ_type_get (state, container->type); val_t val = PJ_value_get_or_new (value, NULL, type); /* if user didn't declare a value with a color, user a NULL color */ new_pajePushState(MSG_get_clock(), container, type, val); } /** \ingroup TRACE_user_variables * \brief Pop the last value of a state of a given host. * * Change a user state previously declared by removing the last value of the state. * * \param host The name of the host to be considered. * \param state The name of the state to be popped. * * \see TRACE_host_state_declare, TRACE_host_set_state, TRACE_host_push_state, TRACE_host_reset_state */ void TRACE_host_pop_state (const char *host, const char *state) { container_t container = PJ_container_get(host); type_t type = PJ_type_get (state, container->type); new_pajePopState(MSG_get_clock(), container, type); } /** \ingroup TRACE_user_variables * \brief Reset the state of a given host. * * Clear all previous values of a user state. * * \param host The name of the host to be considered. * \param state The name of the state to be cleared. * * \see TRACE_host_state_declare, TRACE_host_set_state, TRACE_host_push_state, TRACE_host_pop_state */ void TRACE_host_reset_state (const char *host, const char *state) { container_t container = PJ_container_get(host); type_t type = PJ_type_get (state, container->type); new_pajeResetState(MSG_get_clock(), container, type); } /** \ingroup TRACE_API * \brief Get Paje container types that can be mapped to the nodes of a graph. * * This function can be used to create a user made * graph configuration file for Triva. Normally, it is * used with the functions defined in \ref TRACE_user_variables. * * \return A dynar with the types, must be freed with xbt_dynar_free. */ xbt_dynar_t TRACE_get_node_types (void) { return instr_dict_to_dynar (trivaNodeTypes); } /** \ingroup TRACE_API * \brief Get Paje container types that can be mapped to the edges of a graph. * * This function can be used to create a user made * graph configuration file for Triva. Normally, it is * used with the functions defined in \ref TRACE_user_variables. * * \return A dynar with the types, must be freed with xbt_dynar_free. */ xbt_dynar_t TRACE_get_edge_types (void) { return instr_dict_to_dynar (trivaEdgeTypes); } /** \ingroup TRACE_API * \brief Pauses all tracing activities. * \see TRACE_resume */ void TRACE_pause (void) { instr_pause_tracing(); } /** \ingroup TRACE_API * \brief Resumes all tracing activities. * \see TRACE_pause */ void TRACE_resume (void) { instr_resume_tracing(); } #endif /* HAVE_TRACING */ SimGrid-3.11/src/instr/instr_TI_trace.c000644 001750 001750 00000021132 12342443651 017032 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "instr/instr_private.h" #include "xbt/virtu.h" /* sg_cmdline */ #include "xbt/xbt_os_time.h" #include "simgrid/sg_config.h" #include #include #include XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_TI_trace, instr_trace, "tracing event system"); extern FILE *tracing_file; double prefix=0.0; xbt_dict_t tracing_files = NULL; extern s_instr_trace_writer_t active_writer; void TRACE_TI_init(void) { active_writer.print_PushState = print_TIPushState; active_writer.print_CreateContainer=print_TICreateContainer; active_writer.print_DestroyContainer=print_TIDestroyContainer; } void TRACE_TI_start(void) { char *filename = TRACE_get_filename(); tracing_file = fopen(filename, "w"); if (tracing_file == NULL) { THROWF(system_error, 1, "Tracefile %s could not be opened for writing.", filename); } XBT_DEBUG("Filename %s is open for writing", filename); /* output one line comment */ dump_comment(TRACE_get_comment()); /* output comment file */ dump_comment_file(TRACE_get_comment_file()); } void TRACE_TI_end(void) { xbt_dict_free(&tracing_files); fclose(tracing_file); char *filename = TRACE_get_filename(); XBT_DEBUG("Filename %s is closed", filename); } void print_TICreateContainer(paje_event_t event) { //if we are in the mode with only one file static FILE *temp = NULL; if (tracing_files == NULL) { tracing_files = xbt_dict_new_homogeneous(NULL); //generate unique run id with time prefix = xbt_os_time(); } if (!xbt_cfg_get_boolean(_sg_cfg_set, "tracing/smpi/format/ti_one_file") || temp == NULL) { char *folder_name = bprintf("%s_files", TRACE_get_filename()); char *filename = bprintf("%s/%f_%s.txt", folder_name, prefix, ((createContainer_t) event->data)->container->name); #ifdef WIN32 mkdir(folder_name); #else mkdir(folder_name, S_IRWXU | S_IRWXG | S_IRWXO); #endif temp = fopen(filename, "w"); if (temp == NULL) xbt_die("Tracefile %s could not be opened for writing: %s", filename, strerror(errno)); fprintf(tracing_file, "%s\n", filename); xbt_free(folder_name); xbt_free(filename); } xbt_dict_set(tracing_files, ((createContainer_t) event->data)->container->name, (void *) temp, NULL); } void print_TIDestroyContainer(paje_event_t event) { if (!xbt_cfg_get_boolean(_sg_cfg_set, "tracing/smpi/format/ti_one_file")|| xbt_dict_length(tracing_files) == 1) { FILE* f = xbt_dict_get_or_null(tracing_files, ((destroyContainer_t) event->data)->container->name); fclose(f); } xbt_dict_remove(tracing_files, ((destroyContainer_t) event->data)->container->name); } void print_TIPushState(paje_event_t event) { int i; //char* function=NULL; if (((pushState_t) event->data)->extra == NULL) return; instr_extra_data extra = (instr_extra_data) (((pushState_t) event->data)->extra); char *process_id = NULL; //FIXME: dirty extract "rank-" from the name, as we want the bare process id here if (strstr(((pushState_t) event->data)->container->name, "rank-") == NULL) process_id = xbt_strdup(((pushState_t) event->data)->container->name); else process_id = xbt_strdup(((pushState_t) event->data)->container->name + 5); FILE* trace_file = (FILE* )xbt_dict_get(tracing_files, ((pushState_t) event->data)->container->name); switch (extra->type) { case TRACING_INIT: fprintf(trace_file, "%s init\n", process_id); break; case TRACING_FINALIZE: fprintf(trace_file, "%s finalize\n", process_id); break; case TRACING_SEND: fprintf(trace_file, "%s send %d %d %s\n", process_id, extra->dst, extra->send_size, extra->datatype1); break; case TRACING_ISEND: fprintf(trace_file, "%s isend %d %d %s\n", process_id, extra->dst, extra->send_size, extra->datatype1); break; case TRACING_RECV: fprintf(trace_file, "%s recv %d %d %s\n", process_id, extra->src, extra->send_size, extra->datatype1); break; case TRACING_IRECV: fprintf(trace_file, "%s irecv %d %d %s\n", process_id, extra->src, extra->send_size, extra->datatype1); break; case TRACING_TEST: fprintf(trace_file, "%s test\n", process_id); break; case TRACING_WAIT: fprintf(trace_file, "%s wait\n", process_id); break; case TRACING_WAITALL: fprintf(trace_file, "%s waitall\n", process_id); break; case TRACING_BARRIER: fprintf(trace_file, "%s barrier\n", process_id); break; case TRACING_BCAST: // rank bcast size (root) (datatype) fprintf(trace_file, "%s bcast %d ", process_id, extra->send_size); if (extra->root != 0 || (extra->datatype1 && strcmp(extra->datatype1, ""))) fprintf(trace_file, "%d %s", extra->root, extra->datatype1); fprintf(trace_file, "\n"); break; case TRACING_REDUCE: // rank reduce comm_size comp_size (root) (datatype) fprintf(trace_file, "%s reduce %d %f ", process_id, extra->send_size, extra->comp_size); if (extra->root != 0 || (extra->datatype1 && strcmp(extra->datatype1, ""))) fprintf(trace_file, "%d %s", extra->root, extra->datatype1); fprintf(trace_file, "\n"); break; case TRACING_ALLREDUCE: // rank allreduce comm_size comp_size (datatype) fprintf(trace_file, "%s allreduce %d %f %s\n", process_id, extra->send_size, extra->comp_size, extra->datatype1); break; case TRACING_ALLTOALL: // rank alltoall send_size recv_size (sendtype) (recvtype) fprintf(trace_file, "%s alltoall %d %d %s %s\n", process_id, extra->send_size, extra->recv_size, extra->datatype1, extra->datatype2); break; case TRACING_ALLTOALLV: // rank alltoallv send_size [sendcounts] recv_size [recvcounts] (sendtype) (recvtype) fprintf(trace_file, "%s alltoallv %d ", process_id, extra->send_size); for (i = 0; i < extra->num_processes; i++) fprintf(trace_file, "%d ", extra->sendcounts[i]); fprintf(trace_file, "%d ", extra->recv_size); for (i = 0; i < extra->num_processes; i++) fprintf(trace_file, "%d ", extra->recvcounts[i]); fprintf(trace_file, "%s %s \n", extra->datatype1, extra->datatype2); break; case TRACING_GATHER: // rank gather send_size recv_size root (sendtype) (recvtype) fprintf(trace_file, "%s gather %d %d %d %s %s\n", process_id, extra->send_size, extra->recv_size, extra->root, extra->datatype1, extra->datatype2); break; case TRACING_ALLGATHERV: // rank allgatherv send_size [recvcounts] (sendtype) (recvtype) fprintf(trace_file, "%s allgatherv %d ", process_id, extra->send_size); for (i = 0; i < extra->num_processes; i++) fprintf(trace_file, "%d ", extra->recvcounts[i]); fprintf(trace_file, "%s %s \n", extra->datatype1, extra->datatype2); break; case TRACING_REDUCE_SCATTER: // rank reducescatter [recvcounts] comp_size (sendtype) fprintf(trace_file, "%s reducescatter ", process_id); for (i = 0; i < extra->num_processes; i++) fprintf(trace_file, "%d ", extra->recvcounts[i]); fprintf(trace_file, "%f %s\n", extra->comp_size, extra->datatype1); break; case TRACING_COMPUTING: fprintf(trace_file, "%s compute %f\n", process_id, extra->comp_size); break; case TRACING_SLEEPING: fprintf(trace_file, "%s sleep %f\n", process_id, extra->sleep_duration); break; case TRACING_GATHERV: // rank gatherv send_size [recvcounts] root (sendtype) (recvtype) fprintf(trace_file, "%s gatherv %d ", process_id, extra->send_size); for (i = 0; i < extra->num_processes; i++) fprintf(trace_file, "%d ", extra->recvcounts[i]); fprintf(trace_file, "%d %s %s\n", extra->root, extra->datatype1, extra->datatype2); break; case TRACING_WAITANY: case TRACING_SENDRECV: case TRACING_SCATTER: case TRACING_SCATTERV: case TRACING_ALLGATHER: case TRACING_SCAN: case TRACING_EXSCAN: case TRACING_COMM_SIZE: case TRACING_COMM_SPLIT: case TRACING_COMM_DUP: case TRACING_SSEND: case TRACING_ISSEND: default: XBT_WARN ("Call from %s impossible to translate into replay command : Not implemented (yet)", ((pushState_t) event->data)->value->name); break; } if (extra->recvcounts != NULL) xbt_free(extra->recvcounts); if (extra->sendcounts != NULL) xbt_free(extra->sendcounts); xbt_free(process_id); xbt_free(extra); } SimGrid-3.11/src/instr/instr_config.c000644 001750 001750 00000073545 12342443651 016624 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "instr/instr_private.h" #include "simgrid/sg_config.h" #include "surf/surf.h" #ifdef HAVE_TRACING XBT_LOG_NEW_CATEGORY(instr, "Logging the behavior of the tracing system (used for Visualization/Analysis of simulations)"); XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_config, instr, "Configuration"); #define OPT_TRACING "tracing" #define OPT_TRACING_PLATFORM "tracing/platform" #define OPT_TRACING_TOPOLOGY "tracing/platform/topology" #define OPT_TRACING_SMPI "tracing/smpi" #define OPT_TRACING_SMPI_GROUP "tracing/smpi/group" #define OPT_TRACING_SMPI_COMPUTING "tracing/smpi/computing" #define OPT_TRACING_SMPI_SLEEPING "tracing/smpi/sleeping" #define OPT_TRACING_SMPI_INTERNALS "tracing/smpi/internals" #define OPT_TRACING_DISPLAY_SIZES "tracing/smpi/display_sizes" #define OPT_TRACING_FORMAT "tracing/smpi/format" #define OPT_TRACING_FORMAT_TI_ONEFILE "tracing/smpi/format/ti_one_file" #define OPT_TRACING_CATEGORIZED "tracing/categorized" #define OPT_TRACING_UNCATEGORIZED "tracing/uncategorized" #define OPT_TRACING_MSG_PROCESS "tracing/msg/process" #define OPT_TRACING_MSG_VM "tracing/msg/vm" #define OPT_TRACING_FILENAME "tracing/filename" #define OPT_TRACING_BUFFER "tracing/buffer" #define OPT_TRACING_ONELINK_ONLY "tracing/onelink_only" #define OPT_TRACING_DISABLE_DESTROY "tracing/disable_destroy" #define OPT_TRACING_BASIC "tracing/basic" #define OPT_TRACING_COMMENT "tracing/comment" #define OPT_TRACING_COMMENT_FILE "tracing/comment_file" #define OPT_VIVA_UNCAT_CONF "viva/uncategorized" #define OPT_VIVA_CAT_CONF "viva/categorized" #define OPT_TRACING_DISABLE_LINK "tracing/disable_link" #define OPT_TRACING_DISABLE_POWER "tracing/disable_power" static int trace_enabled = 0; static int trace_platform; static int trace_platform_topology; static int trace_smpi_enabled; static int trace_smpi_grouped; static int trace_smpi_computing; static int trace_smpi_sleeping; static int trace_view_internals; static int trace_categorized; static int trace_uncategorized; static int trace_msg_process_enabled; static int trace_msg_vm_enabled; static int trace_buffer; static int trace_onelink_only; static int trace_disable_destroy; static int trace_basic; static int trace_display_sizes = 0; static int trace_disable_link; static int trace_disable_power; static int trace_configured = 0; static int trace_active = 0; static void TRACE_getopts(void) { trace_enabled = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING); trace_platform = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_PLATFORM); trace_platform_topology = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_TOPOLOGY); trace_smpi_enabled = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_SMPI); trace_smpi_grouped = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_SMPI_GROUP); trace_smpi_computing = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_SMPI_COMPUTING); trace_smpi_sleeping = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_SMPI_SLEEPING); trace_view_internals = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_SMPI_INTERNALS); trace_categorized = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_CATEGORIZED); trace_uncategorized = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_UNCATEGORIZED); trace_msg_process_enabled = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_MSG_PROCESS); trace_msg_vm_enabled = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_MSG_VM); trace_buffer = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_BUFFER); trace_onelink_only = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_ONELINK_ONLY); trace_disable_destroy = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_DESTROY); trace_basic = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_BASIC); trace_display_sizes = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_DISPLAY_SIZES); trace_disable_link = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_LINK); trace_disable_power = xbt_cfg_get_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_POWER); } static xbt_dynar_t TRACE_start_functions = NULL; void TRACE_add_start_function(void (*func) ()) { if (TRACE_start_functions == NULL) TRACE_start_functions = xbt_dynar_new(sizeof(void (*)()), NULL); xbt_dynar_push(TRACE_start_functions, &func); } int TRACE_start() { if (TRACE_is_configured()) TRACE_getopts(); // tracing system must be: // - enabled (with --cfg=tracing:yes) // - already configured (TRACE_global_init already called) if (TRACE_is_enabled()) { XBT_DEBUG("Tracing starts"); /* init the tracing module to generate the right output */ /* open internal buffer */ TRACE_init(); /* open the trace file(s) */ const char* format = sg_cfg_get_string(OPT_TRACING_FORMAT); XBT_DEBUG("Tracing format %s\n", format); if(!strcmp(format, "Paje")){ TRACE_paje_init(); TRACE_paje_start(); }else if (!strcmp(format, "TI")){ TRACE_TI_init(); TRACE_TI_start(); }else{ xbt_die("Unknown trace format :%s ", format); } /* activate trace */ if (trace_active == 1) { THROWF(tracing_error, 0, "Tracing is already active"); } trace_active = 1; XBT_DEBUG("Tracing is on"); /* other trace initialization */ created_categories = xbt_dict_new_homogeneous(xbt_free); declared_marks = xbt_dict_new_homogeneous(xbt_free); user_host_variables = xbt_dict_new_homogeneous(xbt_free); user_vm_variables = xbt_dict_new_homogeneous (xbt_free); user_link_variables = xbt_dict_new_homogeneous(xbt_free); if (TRACE_start_functions != NULL) { void (*func) (); unsigned int iter = xbt_dynar_length(TRACE_start_functions); xbt_dynar_foreach(TRACE_start_functions, iter, func) { func(); } } } xbt_dynar_free(&TRACE_start_functions); return 0; } static xbt_dynar_t TRACE_end_functions = NULL; void TRACE_add_end_function(void (*func) (void)) { if (TRACE_end_functions == NULL) TRACE_end_functions = xbt_dynar_new(sizeof(void (*)(void)), NULL); xbt_dynar_push(TRACE_end_functions, &func); } int TRACE_end() { int retval; if (!trace_active) { retval = 1; } else { retval = 0; TRACE_generate_viva_uncat_conf(); TRACE_generate_viva_cat_conf(); /* dump trace buffer */ TRACE_last_timestamp_to_dump = surf_get_clock(); TRACE_paje_dump_buffer(1); /* destroy all data structures of tracing (and free) */ PJ_container_free_all(); PJ_type_free_all(); PJ_container_release(); PJ_type_release(); if (TRACE_end_functions != NULL) { void (*func) (void); unsigned int iter; xbt_dynar_foreach(TRACE_end_functions, iter, func) { func(); } } xbt_dict_free(&user_link_variables); xbt_dict_free(&user_host_variables); xbt_dict_free(&user_vm_variables); xbt_dict_free(&declared_marks); xbt_dict_free(&created_categories); /* close the trace files */ const char* format = sg_cfg_get_string(OPT_TRACING_FORMAT); XBT_DEBUG("Tracing format %s\n", format); if(!strcmp(format, "Paje")){ TRACE_paje_end(); }else if (!strcmp(format, "TI")){ TRACE_TI_end(); }else{ xbt_die("Unknown trace format :%s ", format); } /* close internal buffer */ TRACE_finalize(); /* de-activate trace */ trace_active = 0; XBT_DEBUG("Tracing is off"); XBT_DEBUG("Tracing system is shutdown"); } xbt_dynar_free(&TRACE_start_functions); /* useful when exiting early */ xbt_dynar_free(&TRACE_end_functions); return retval; } int TRACE_needs_platform (void) { return TRACE_msg_process_is_enabled() || TRACE_msg_vm_is_enabled() || TRACE_categorized() || TRACE_uncategorized() || TRACE_platform () || (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped()); } int TRACE_is_enabled(void) { return trace_enabled; } int TRACE_platform(void) { return trace_platform; } int TRACE_platform_topology(void) { return trace_platform_topology; } int TRACE_is_configured(void) { return trace_configured; } int TRACE_smpi_is_enabled(void) { return (trace_smpi_enabled || TRACE_smpi_is_grouped()) && TRACE_is_enabled(); } int TRACE_smpi_is_grouped(void) { return trace_smpi_grouped; } int TRACE_smpi_is_computing(void) { return trace_smpi_computing; } int TRACE_smpi_is_sleeping(void) { return trace_smpi_sleeping; } int TRACE_smpi_view_internals(void) { return trace_view_internals; } int TRACE_categorized (void) { return trace_categorized; } int TRACE_uncategorized (void) { return trace_uncategorized; } int TRACE_msg_process_is_enabled(void) { return trace_msg_process_enabled && TRACE_is_enabled(); } int TRACE_msg_vm_is_enabled(void) { return trace_msg_vm_enabled && TRACE_is_enabled(); } int TRACE_disable_link(void) { return trace_disable_link && TRACE_is_enabled(); } int TRACE_disable_power(void) { return trace_disable_power && TRACE_is_enabled(); } int TRACE_buffer (void) { return trace_buffer && TRACE_is_enabled(); } int TRACE_onelink_only (void) { return trace_onelink_only && TRACE_is_enabled(); } int TRACE_disable_destroy (void) { return trace_disable_destroy && TRACE_is_enabled(); } int TRACE_basic (void) { return trace_basic && TRACE_is_enabled(); } int TRACE_display_sizes (void) { return trace_display_sizes && trace_smpi_enabled && TRACE_is_enabled(); } char *TRACE_get_comment (void) { return xbt_cfg_get_string(_sg_cfg_set, OPT_TRACING_COMMENT); } char *TRACE_get_comment_file (void) { return xbt_cfg_get_string(_sg_cfg_set, OPT_TRACING_COMMENT_FILE); } char *TRACE_get_filename(void) { return xbt_cfg_get_string(_sg_cfg_set, OPT_TRACING_FILENAME); } char *TRACE_get_viva_uncat_conf (void) { return xbt_cfg_get_string(_sg_cfg_set, OPT_VIVA_UNCAT_CONF); } char *TRACE_get_viva_cat_conf (void) { return xbt_cfg_get_string(_sg_cfg_set, OPT_VIVA_CAT_CONF); } void TRACE_global_init(int *argc, char **argv) { /* name of the tracefile */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_FILENAME, "Trace file created by the instrumented SimGrid.", xbt_cfgelm_string, 1, 1, NULL, NULL); xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_FILENAME, "simgrid.trace"); /* tracing */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING, "Enable Tracing.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING, "no"); /* register platform in the trace */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_PLATFORM, "Register the platform in the trace as a hierarchy.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_PLATFORM, "no"); /* register platform in the trace */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_TOPOLOGY, "Register the platform topology in the trace as a graph.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_TOPOLOGY, "yes"); /* smpi */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI, "Tracing of the SMPI interface.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI, "no"); /* smpi grouped */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_GROUP, "Group MPI processes by host.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI_GROUP, "no"); /* smpi computing */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_COMPUTING, "Generate states for timing out of SMPI parts of the application", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI_COMPUTING, "no"); /* smpi sleeping */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_SLEEPING, "Generate states for timing out of SMPI parts of the application", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI_SLEEPING, "no"); /* smpi internals */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_SMPI_INTERNALS, "View internal messages sent by Collective communications in SMPI", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_SMPI_INTERNALS, "no"); /* tracing categorized resource utilization traces */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_CATEGORIZED, "Tracing categorized resource utilization of hosts and links.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_CATEGORIZED, "no"); /* tracing uncategorized resource utilization */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_UNCATEGORIZED, "Tracing uncategorized resource utilization of hosts and links.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_UNCATEGORIZED, "no"); /* msg process */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_MSG_PROCESS, "Tracing of MSG process behavior.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_MSG_PROCESS, "no"); /* msg process */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_MSG_VM, "Tracing of MSG process behavior.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_MSG_VM, "no"); /* disable tracing link */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISABLE_LINK, "Do not trace link bandwidth and latency.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_LINK, "no"); /* disable tracing link */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISABLE_POWER, "Do not trace host power.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_POWER, "no"); /* tracing buffer */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_BUFFER, "Buffer trace events to put them in temporal order.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_BUFFER, "yes"); /* tracing one link only */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_ONELINK_ONLY, "Use only routes with one link to trace platform.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_ONELINK_ONLY, "no"); /* disable destroy */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISABLE_DESTROY, "Disable platform containers destruction.", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_DISABLE_DESTROY, "no"); /* basic -- Avoid extended events (impoverished trace file) */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_BASIC, "Avoid extended events (impoverished trace file).", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_BASIC, "no"); /* display_sizes -- Extended events with message size information */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_DISPLAY_SIZES, "(smpi only for now) Extended events with message size information", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_DISPLAY_SIZES, "no"); /* format -- Switch the ouput format of Tracing */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_FORMAT, "(smpi only for now) Switch the ouput format of Tracing", xbt_cfgelm_string, 1, 1, NULL, NULL); xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_FORMAT, "Paje"); /* format -- Switch the ouput format of Tracing */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_FORMAT_TI_ONEFILE, "(smpi only for now) For replay format only : output to one file only", xbt_cfgelm_boolean, 1, 1, NULL, NULL); xbt_cfg_setdefault_boolean(_sg_cfg_set, OPT_TRACING_FORMAT_TI_ONEFILE, "no"); /* comment */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_COMMENT, "Comment to be added on the top of the trace file.", xbt_cfgelm_string, 1, 1, NULL, NULL); xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_COMMENT, ""); /* comment_file */ xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_COMMENT_FILE, "The contents of the file are added to the top of the trace file as comment.", xbt_cfgelm_string, 1, 1, NULL, NULL); xbt_cfg_setdefault_string(_sg_cfg_set, OPT_TRACING_COMMENT_FILE, ""); /* Viva graph configuration for uncategorized tracing */ xbt_cfg_register(&_sg_cfg_set, OPT_VIVA_UNCAT_CONF, "Viva Graph configuration file for uncategorized resource utilization traces.", xbt_cfgelm_string, 1, 1, NULL, NULL); xbt_cfg_setdefault_string(_sg_cfg_set, OPT_VIVA_UNCAT_CONF, ""); /* Viva graph configuration for uncategorized tracing */ xbt_cfg_register(&_sg_cfg_set, OPT_VIVA_CAT_CONF, "Viva Graph configuration file for categorized resource utilization traces.", xbt_cfgelm_string, 1, 1, NULL, NULL); xbt_cfg_setdefault_string(_sg_cfg_set, OPT_VIVA_CAT_CONF, ""); /* instrumentation can be considered configured now */ trace_configured = 1; } static void print_line (const char *option, const char *desc, const char *longdesc, int detailed) { char str[INSTR_DEFAULT_STR_SIZE]; snprintf (str, INSTR_DEFAULT_STR_SIZE, "--cfg=%s ", option); int len = strlen (str); printf ("%s%*.*s %s\n", str, 30-len, 30-len, "", desc); if (!!longdesc && detailed){ printf ("%s\n\n", longdesc); } } void TRACE_help (int detailed) { printf( "Description of the tracing options accepted by this simulator:\n\n"); print_line (OPT_TRACING, "Enable the tracing system", " It activates the tracing system and register the simulation platform\n" " in the trace file. You have to enable this option to others take effect.", detailed); print_line (OPT_TRACING_CATEGORIZED, "Trace categorized resource utilization", " It activates the categorized resource utilization tracing. It should\n" " be enabled if tracing categories are used by this simulator.", detailed); print_line (OPT_TRACING_UNCATEGORIZED, "Trace uncategorized resource utilization", " It activates the uncategorized resource utilization tracing. Use it if\n" " this simulator do not use tracing categories and resource use have to be\n" " traced.", detailed); print_line (OPT_TRACING_FILENAME, "Filename to register traces", " A file with this name will be created to register the simulation. The file\n" " is in the Paje format and can be analyzed using Viva, Paje, and PajeNG visualization\n" " tools. More information can be found in these webpages:\n" " http://github.com/schnorr/viva/\n" " http://github.com/schnorr/pajeng/\n" " http://paje.sourceforge.net/", detailed); print_line (OPT_TRACING_SMPI, "Trace the MPI Interface (SMPI)", " This option only has effect if this simulator is SMPI-based. Traces the MPI\n" " interface and generates a trace that can be analyzed using Gantt-like\n" " visualizations. Every MPI function (implemented by SMPI) is transformed in a\n" " state, and point-to-point communications can be analyzed with arrows.", detailed); print_line (OPT_TRACING_SMPI_GROUP, "Group MPI processes by host (SMPI)", " This option only has effect if this simulator is SMPI-based. The processes\n" " are grouped by the hosts where they were executed.", detailed); print_line (OPT_TRACING_SMPI_COMPUTING, "Generates a \" Computing \" State", " This option aims at tracing computations in the application, outside SMPI\n" " to allow further study of simulated or real computation time", detailed); print_line (OPT_TRACING_SMPI_SLEEPING, "Generates a \" Sleeping \" State", " This option aims at tracing sleeps in the application, outside SMPI\n" " to allow further study of simulated or real sleep time", detailed); print_line (OPT_TRACING_SMPI_INTERNALS, "Generates tracing events corresponding", " to point-to-point messages sent by collective communications", detailed); print_line (OPT_TRACING_MSG_PROCESS, "Trace processes behavior (MSG)", " This option only has effect if this simulator is MSG-based. It traces the\n" " behavior of all categorized MSG processes, grouping them by hosts. This option\n" " can be used to track process location if this simulator has process migration.", detailed); print_line (OPT_TRACING_BUFFER, "Buffer events to put them in temporal order", " This option put some events in a time-ordered buffer using the insertion\n" " sort algorithm. The process of acquiring and releasing locks to access this\n" " buffer and the cost of the sorting algorithm make this process slow. The\n" " simulator performance can be severely impacted if this option is activated,\n" " but you are sure to get a trace file with events sorted.", detailed); print_line (OPT_TRACING_ONELINK_ONLY, "Consider only one link routes to trace platform", " This option changes the way SimGrid register its platform on the trace file.\n" " Normally, the tracing considers all routes (no matter their size) on the\n" " platform file to re-create the resource topology. If this option is activated,\n" " only the routes with one link are used to register the topology within an AS.\n" " Routes among AS continue to be traced as usual.", detailed); print_line (OPT_TRACING_DISABLE_DESTROY, "Disable platform containers destruction", " Disable the destruction of containers at the end of simulation. This can be\n" " used with simulators that have a different notion of time (different from\n" " the simulated time).", detailed); print_line (OPT_TRACING_BASIC, "Avoid extended events (impoverished trace file).", " Some visualization tools are not able to parse correctly the Paje file format.\n" " Use this option if you are using one of these tools to visualize the simulation\n" " trace. Keep in mind that the trace might be incomplete, without all the\n" " information that would be registered otherwise.", detailed); print_line (OPT_TRACING_DISPLAY_SIZES, "Only works for SMPI now. Add message size information", " Message size (in bytes) is added to links, and to states. For collectives,\n" " the displayed value is the more relevant to the collective (total sent by\n" " the process, usually)", detailed); print_line (OPT_TRACING_FORMAT, "Only works for SMPI now. Switch output format", " Default format is Paje. Time independent traces are also supported,\n" " to output traces that can later be used by the trace replay tool", detailed); print_line (OPT_TRACING_FORMAT_TI_ONEFILE, "Only works for SMPI now, and TI output format", " By default, each process outputs to a separate file, inside a filename_files folder\n" " By setting this option to yes, all processes will output to only one file\n" " This is meant to avoid opening thousands of files with large simulations", detailed); print_line (OPT_TRACING_COMMENT, "Comment to be added on the top of the trace file.", " Use this to add a comment line to the top of the trace file.", detailed); print_line (OPT_TRACING_COMMENT_FILE, "File contents added to trace file as comment.", " Use this to add the contents of a file to the top of the trace file as comment.", detailed); print_line (OPT_VIVA_UNCAT_CONF, "Generate a graph configuration for Viva", " This option can be used in all types of simulators build with SimGrid\n" " to generate a uncategorized resource utilization graph to be used as\n" " configuration for the Viva visualization tool. This option\n" " can be used with tracing/categorized:1 and tracing:1 options to\n" " analyze an unmodified simulator before changing it to contain\n" " categories.", detailed); print_line (OPT_VIVA_CAT_CONF, "Generate an uncategorized graph configuration for Viva", " This option can be used if this simulator uses tracing categories\n" " in its code. The file specified by this option holds a graph configuration\n" " file for the Viva visualization tool that can be used to analyze a categorized\n" " resource utilization.", detailed); print_line (OPT_TRACING_TOPOLOGY, "Register the platform topology as a graph", " This option (enabled by default) can be used to disable the tracing of\n" " the platform topology in the trace file. Sometimes, such task is really\n" " time consuming, since it must get the route from each host ot other hosts\n" " within the same Autonomous System (AS).", detailed); } static void output_types (const char *name, xbt_dynar_t types, FILE *file) { unsigned int i; fprintf (file, " %s = (", name); for (i = xbt_dynar_length(types); i > 0; i--) { char *type = *(char**)xbt_dynar_get_ptr(types, i - 1); fprintf (file, "\"%s\"", type); if (i - 1 > 0){ fprintf (file, ","); }else{ fprintf (file, ");\n"); } } xbt_dynar_free (&types); } static void output_categories (const char *name, xbt_dynar_t cats, FILE *file) { unsigned int i; fprintf (file, " values = ("); for (i = xbt_dynar_length(cats); i > 0; i--) { char *cat = *(char**)xbt_dynar_get_ptr(cats, i - 1); fprintf (file, "\"%s%s\"", name, cat); if (i - 1 > 0){ fprintf (file, ","); }else{ fprintf (file, ");\n"); } } xbt_dynar_free (&cats); } static void uncat_configuration (FILE *file) { //register NODE and EDGE types output_types ("node", TRACE_get_node_types(), file); output_types ("edge", TRACE_get_edge_types(), file); fprintf (file, "\n"); //configuration for all nodes fprintf (file, " host = {\n" " type = \"square\";\n" " size = \"power\";\n" " values = (\"power_used\");\n" " };\n" " link = {\n" " type = \"rhombus\";\n" " size = \"bandwidth\";\n" " values = (\"bandwidth_used\");\n" " };\n"); //close } static void cat_configuration (FILE *file) { //register NODE and EDGE types output_types ("node", TRACE_get_node_types(), file); output_types ("edge", TRACE_get_edge_types(), file); fprintf (file, "\n"); //configuration for all nodes fprintf (file, " host = {\n" " type = \"square\";\n" " size = \"power\";\n"); output_categories ("p", TRACE_get_categories(), file); fprintf (file, " };\n" " link = {\n" " type = \"rhombus\";\n" " size = \"bandwidth\";\n"); output_categories ("b", TRACE_get_categories(), file); fprintf (file, " };\n"); //close } static void generate_uncat_configuration (const char *output, const char *name, int brackets) { if (output && strlen(output) > 0){ FILE *file = fopen (output, "w"); if (file == NULL){ THROWF (system_error, 1, "Unable to open file (%s) for writing %s graph " "configuration (uncategorized).", output, name); } if (brackets) fprintf (file, "{\n"); uncat_configuration (file); if (brackets) fprintf (file, "}\n"); fclose (file); } } static void generate_cat_configuration (const char *output, const char *name, int brackets) { if (output && strlen(output) > 0){ //check if we do have categories declared if (xbt_dict_is_empty(created_categories)){ XBT_INFO("No categories declared, ignoring generation of %s graph configuration", name); return; } FILE *file = fopen (output, "w"); if (file == NULL){ THROWF (system_error, 1, "Unable to open file (%s) for writing %s graph " "configuration (categorized).", output, name); } if (brackets) fprintf (file, "{\n"); cat_configuration (file); if (brackets) fprintf (file, "}\n"); fclose (file); } } void TRACE_generate_viva_uncat_conf (void) { generate_uncat_configuration (TRACE_get_viva_uncat_conf (), "viva", 0); } void TRACE_generate_viva_cat_conf (void) { generate_cat_configuration (TRACE_get_viva_cat_conf(), "viva", 0); } static int previous_trace_state = -1; void instr_pause_tracing (void) { previous_trace_state = trace_enabled; if (!TRACE_is_enabled()){ XBT_DEBUG ("Tracing is already paused, therefore do nothing."); }else{ XBT_DEBUG ("Tracing is being paused."); } trace_enabled = 0; XBT_DEBUG ("Tracing is paused."); } void instr_resume_tracing (void) { if (TRACE_is_enabled()){ XBT_DEBUG ("Tracing is already running while trying to resume, therefore do nothing."); }else{ XBT_DEBUG ("Tracing is being resumed."); } if (previous_trace_state != -1){ trace_enabled = previous_trace_state; }else{ trace_enabled = 1; } XBT_DEBUG ("Tracing is resumed."); previous_trace_state = -1; } #undef OPT_TRACING #undef OPT_TRACING_PLATFORM #undef OPT_TRACING_TOPOLOGY #undef OPT_TRACING_SMPI #undef OPT_TRACING_SMPI_GROUP #undef OPT_TRACING_CATEGORIZED #undef OPT_TRACING_UNCATEGORIZED #undef OPT_TRACING_MSG_PROCESS #undef OPT_TRACING_FILENAME #undef OPT_TRACING_BUFFER #undef OPT_TRACING_ONELINK_ONLY #undef OPT_TRACING_DISABLE_DESTROY #undef OPT_TRACING_BASIC #undef OPT_TRACING_COMMENT #undef OPT_TRACING_COMMENT_FILE #undef OPT_VIVA_UNCAT_CONF #undef OPT_VIVA_CAT_CONF #endif /* HAVE_TRACING */ SimGrid-3.11/src/instr/instr_paje_header.c000644 001750 001750 00000022674 12342443651 017603 0ustar00cici000000 000000 /* Copyright (c) 2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "instr/instr_private.h" #ifdef HAVE_TRACING XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_paje_header, instr, "Paje tracing event system (header)"); extern FILE *tracing_file; static void TRACE_header_PajeDefineContainerType (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeDefineContainerType %d\n", PAJE_DefineContainerType); fprintf(tracing_file, "%% Alias string\n"); if (basic){ fprintf(tracing_file, "%% ContainerType string\n"); }else{ fprintf(tracing_file, "%% Type string\n"); } fprintf(tracing_file, "%% Name string\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeDefineVariableType (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeDefineVariableType %d\n", PAJE_DefineVariableType); fprintf(tracing_file, "%% Alias string\n"); if (basic){ fprintf(tracing_file, "%% ContainerType string\n"); }else{ fprintf(tracing_file, "%% Type string\n"); } fprintf(tracing_file, "%% Name string\n"); fprintf(tracing_file, "%% Color color\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeDefineStateType (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeDefineStateType %d\n", PAJE_DefineStateType); fprintf(tracing_file, "%% Alias string\n"); if (basic){ fprintf(tracing_file, "%% ContainerType string\n"); }else{ fprintf(tracing_file, "%% Type string\n"); } fprintf(tracing_file, "%% Name string\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeDefineEventType (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeDefineEventType %d\n", PAJE_DefineEventType); fprintf(tracing_file, "%% Alias string\n"); if (basic){ fprintf(tracing_file, "%% ContainerType string\n"); }else{ fprintf(tracing_file, "%% Type string\n"); } fprintf(tracing_file, "%% Name string\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeDefineLinkType (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeDefineLinkType %d\n", PAJE_DefineLinkType); fprintf(tracing_file, "%% Alias string\n"); if (basic){ fprintf(tracing_file, "%% ContainerType string\n"); fprintf(tracing_file, "%% SourceContainerType string\n"); fprintf(tracing_file, "%% DestContainerType string\n"); }else{ fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% StartContainerType string\n"); fprintf(tracing_file, "%% EndContainerType string\n"); } fprintf(tracing_file, "%% Name string\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeDefineEntityValue (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeDefineEntityValue %d\n", PAJE_DefineEntityValue); fprintf(tracing_file, "%% Alias string\n"); if (basic){ fprintf(tracing_file, "%% EntityType string\n"); }else{ fprintf(tracing_file, "%% Type string\n"); } fprintf(tracing_file, "%% Name string\n"); fprintf(tracing_file, "%% Color color\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeCreateContainer (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeCreateContainer %d\n", PAJE_CreateContainer); fprintf(tracing_file, "%% Time date\n"); fprintf(tracing_file, "%% Alias string\n"); fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% Container string\n"); fprintf(tracing_file, "%% Name string\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeDestroyContainer (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeDestroyContainer %d\n", PAJE_DestroyContainer); fprintf(tracing_file, "%% Time date\n"); fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% Name string\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeSetVariable (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeSetVariable %d\n", PAJE_SetVariable); fprintf(tracing_file, "%% Time date\n"); fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% Container string\n"); fprintf(tracing_file, "%% Value double\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeAddVariable (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeAddVariable %d\n", PAJE_AddVariable); fprintf(tracing_file, "%% Time date\n"); fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% Container string\n"); fprintf(tracing_file, "%% Value double\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeSubVariable (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeSubVariable %d\n", PAJE_SubVariable); fprintf(tracing_file, "%% Time date\n"); fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% Container string\n"); fprintf(tracing_file, "%% Value double\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeSetState (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeSetState %d\n", PAJE_SetState); fprintf(tracing_file, "%% Time date\n"); fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% Container string\n"); fprintf(tracing_file, "%% Value string\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajePushState (int basic, int size) { fprintf(tracing_file, "%%EventDef PajePushState %d\n", PAJE_PushState); fprintf(tracing_file, "%% Time date\n"); fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% Container string\n"); fprintf(tracing_file, "%% Value string\n"); if (size) fprintf(tracing_file, "%% Size int\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajePopState (int basic, int size) { fprintf(tracing_file, "%%EventDef PajePopState %d\n", PAJE_PopState); fprintf(tracing_file, "%% Time date\n"); fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% Container string\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeResetState (int basic, int size) { if (basic) return; fprintf(tracing_file, "%%EventDef PajeResetState %d\n", PAJE_ResetState); fprintf(tracing_file, "%% Time date\n"); fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% Container string\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeStartLink (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeStartLink %d\n", PAJE_StartLink); fprintf(tracing_file, "%% Time date\n"); fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% Container string\n"); fprintf(tracing_file, "%% Value string\n"); if (basic){ fprintf(tracing_file, "%% SourceContainer string\n"); }else{ fprintf(tracing_file, "%% StartContainer string\n"); } fprintf(tracing_file, "%% Key string\n"); if (size) fprintf(tracing_file, "%% Size int\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeEndLink (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeEndLink %d\n", PAJE_EndLink); fprintf(tracing_file, "%% Time date\n"); fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% Container string\n"); fprintf(tracing_file, "%% Value string\n"); if (basic){ fprintf(tracing_file, "%% DestContainer string\n"); }else{ fprintf(tracing_file, "%% EndContainer string\n"); } fprintf(tracing_file, "%% Key string\n"); fprintf(tracing_file, "%%EndEventDef\n"); } static void TRACE_header_PajeNewEvent (int basic, int size) { fprintf(tracing_file, "%%EventDef PajeNewEvent %d\n", PAJE_NewEvent); fprintf(tracing_file, "%% Time date\n"); fprintf(tracing_file, "%% Type string\n"); fprintf(tracing_file, "%% Container string\n"); fprintf(tracing_file, "%% Value string\n"); fprintf(tracing_file, "%%EndEventDef\n"); } void TRACE_header(int basic, int size) { XBT_DEBUG ("Define paje header"); TRACE_header_PajeDefineContainerType (basic, size); TRACE_header_PajeDefineVariableType (basic, size); TRACE_header_PajeDefineStateType (basic, size); TRACE_header_PajeDefineEventType (basic, size); TRACE_header_PajeDefineLinkType (basic, size); TRACE_header_PajeDefineEntityValue (basic, size); TRACE_header_PajeCreateContainer (basic, size); TRACE_header_PajeDestroyContainer (basic, size); TRACE_header_PajeSetVariable (basic, size); TRACE_header_PajeAddVariable (basic, size); TRACE_header_PajeSubVariable (basic, size); TRACE_header_PajeSetState (basic, size); TRACE_header_PajePushState (basic, size); TRACE_header_PajePopState (basic, size); TRACE_header_PajeResetState (basic, size); TRACE_header_PajeStartLink (basic, size); TRACE_header_PajeEndLink (basic, size); TRACE_header_PajeNewEvent (basic, size); } #endif SimGrid-3.11/src/instr/instr_paje_trace.c000644 001750 001750 00000037065 12342443651 017451 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "instr/instr_private.h" #include "xbt/virtu.h" /* sg_cmdline */ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_paje_trace, instr_trace, "tracing event system"); extern FILE * tracing_file; extern s_instr_trace_writer_t active_writer; void TRACE_paje_init(void) { active_writer.print_DefineContainerType=print_pajeDefineContainerType; active_writer.print_DefineVariableType=print_pajeDefineVariableType; active_writer.print_DefineStateType=print_pajeDefineStateType; active_writer.print_DefineEventType=print_pajeDefineEventType; active_writer.print_DefineLinkType=print_pajeDefineLinkType; active_writer.print_DefineEntityValue=print_pajeDefineEntityValue; active_writer.print_CreateContainer=print_pajeCreateContainer; active_writer.print_DestroyContainer=print_pajeDestroyContainer; active_writer.print_SetVariable=print_pajeSetVariable; active_writer.print_AddVariable=print_pajeAddVariable; active_writer.print_SubVariable=print_pajeSubVariable; active_writer.print_SetState=print_pajeSetState; active_writer.print_PushState=print_pajePushState; active_writer.print_PopState=print_pajePopState; active_writer.print_ResetState=print_pajeResetState; active_writer.print_StartLink=print_pajeStartLink; active_writer.print_EndLink=print_pajeEndLink; active_writer.print_NewEvent=print_pajeNewEvent; } void TRACE_paje_start(void) { char *filename = TRACE_get_filename(); tracing_file = fopen(filename, "w"); if (tracing_file == NULL){ THROWF (system_error, 1, "Tracefile %s could not be opened for writing.", filename); } XBT_DEBUG("Filename %s is open for writing", filename); /* output generator version */ fprintf (tracing_file, "#This file was generated using SimGrid-%d.%d.%d\n", SIMGRID_VERSION_MAJOR, SIMGRID_VERSION_MINOR, SIMGRID_VERSION_PATCH); fprintf (tracing_file, "#["); unsigned int cpt; char *str; xbt_dynar_foreach (xbt_cmdline, cpt, str){ fprintf(tracing_file, "%s ",str); } fprintf (tracing_file, "]\n"); /* output one line comment */ dump_comment (TRACE_get_comment()); /* output comment file */ dump_comment_file (TRACE_get_comment_file()); /* output header */ TRACE_header(TRACE_basic(),TRACE_display_sizes()); } void TRACE_paje_end(void) { fclose(tracing_file); char *filename = TRACE_get_filename(); XBT_DEBUG("Filename %s is closed", filename); } void print_pajeDefineContainerType(paje_event_t event) { XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type); fprintf(tracing_file, "%d %s %s %s\n", (int)event->event_type, ((defineContainerType_t)event->data)->type->id, ((defineContainerType_t)event->data)->type->father->id, ((defineContainerType_t)event->data)->type->name); } void print_pajeDefineVariableType(paje_event_t event) { XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type); fprintf(tracing_file, "%d %s %s %s \"%s\"\n", (int)event->event_type, ((defineVariableType_t)event->data)->type->id, ((defineVariableType_t)event->data)->type->father->id, ((defineVariableType_t)event->data)->type->name, ((defineVariableType_t)event->data)->type->color); } void print_pajeDefineStateType(paje_event_t event) { XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type); fprintf(tracing_file, "%d %s %s %s\n", (int)event->event_type, ((defineStateType_t)event->data)->type->id, ((defineStateType_t)event->data)->type->father->id, ((defineStateType_t)event->data)->type->name); } void print_pajeDefineEventType(paje_event_t event) { XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type); fprintf(tracing_file, "%d %s %s %s\n", (int)event->event_type, ((defineEventType_t)event->data)->type->id, ((defineEventType_t)event->data)->type->father->id, ((defineEventType_t)event->data)->type->name); } void print_pajeDefineLinkType(paje_event_t event) { XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type); fprintf(tracing_file, "%d %s %s %s %s %s\n", (int)event->event_type, ((defineLinkType_t)event->data)->type->id, ((defineLinkType_t)event->data)->type->father->id, ((defineLinkType_t)event->data)->source->id, ((defineLinkType_t)event->data)->dest->id, ((defineLinkType_t)event->data)->type->name); } void print_pajeDefineEntityValue (paje_event_t event) { XBT_DEBUG("%s: event_type=%d", __FUNCTION__, (int)event->event_type); fprintf(tracing_file, "%d %s %s %s \"%s\"\n", (int)event->event_type, ((defineEntityValue_t)event->data)->value->id, ((defineEntityValue_t)event->data)->value->father->id, ((defineEntityValue_t)event->data)->value->name, ((defineEntityValue_t)event->data)->value->color); } void print_pajeCreateContainer(paje_event_t event) { XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s %s \"%s\"\n", (int)event->event_type, ((createContainer_t)event->data)->container->id, ((createContainer_t)event->data)->container->type->id, ((createContainer_t)event->data)->container->father->id, ((createContainer_t)event->data)->container->name); }else{ fprintf(tracing_file, "%d %f %s %s %s \"%s\"\n", (int)event->event_type, event->timestamp, ((createContainer_t)event->data)->container->id, ((createContainer_t)event->data)->container->type->id, ((createContainer_t)event->data)->container->father->id, ((createContainer_t)event->data)->container->name); } } void print_pajeDestroyContainer(paje_event_t event) { XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s\n", (int)event->event_type, ((destroyContainer_t)event->data)->container->type->id, ((destroyContainer_t)event->data)->container->id); }else{ fprintf(tracing_file, "%d %f %s %s\n", (int)event->event_type, event->timestamp, ((destroyContainer_t)event->data)->container->type->id, ((destroyContainer_t)event->data)->container->id); } } void print_pajeSetVariable(paje_event_t event) { XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s %f\n", (int)event->event_type, ((setVariable_t)event->data)->type->id, ((setVariable_t)event->data)->container->id, ((setVariable_t)event->data)->value); }else{ fprintf(tracing_file, "%d %f %s %s %f\n", (int)event->event_type, event->timestamp, ((setVariable_t)event->data)->type->id, ((setVariable_t)event->data)->container->id, ((setVariable_t)event->data)->value); } } void print_pajeAddVariable(paje_event_t event) { XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s %f\n", (int)event->event_type, ((addVariable_t)event->data)->type->id, ((addVariable_t)event->data)->container->id, ((addVariable_t)event->data)->value); }else{ fprintf(tracing_file, "%d %f %s %s %f\n", (int)event->event_type, event->timestamp, ((addVariable_t)event->data)->type->id, ((addVariable_t)event->data)->container->id, ((addVariable_t)event->data)->value); } } void print_pajeSubVariable(paje_event_t event) { XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s %f\n", (int)event->event_type, ((subVariable_t)event->data)->type->id, ((subVariable_t)event->data)->container->id, ((subVariable_t)event->data)->value); }else{ fprintf(tracing_file, "%d %f %s %s %f\n", (int)event->event_type, event->timestamp, ((subVariable_t)event->data)->type->id, ((subVariable_t)event->data)->container->id, ((subVariable_t)event->data)->value); } } void print_pajeSetState(paje_event_t event) { XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s %s\n", (int)event->event_type, ((setState_t)event->data)->type->id, ((setState_t)event->data)->container->id, ((setState_t)event->data)->value->id); }else{ fprintf(tracing_file, "%d %f %s %s %s\n", (int)event->event_type, event->timestamp, ((setState_t)event->data)->type->id, ((setState_t)event->data)->container->id, ((setState_t)event->data)->value->id); } } void print_pajePushState(paje_event_t event) { XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); if (!TRACE_display_sizes()){ if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s %s\n", (int)event->event_type, ((pushState_t)event->data)->type->id, ((pushState_t)event->data)->container->id, ((pushState_t)event->data)->value->id); }else{ fprintf(tracing_file, "%d %f %s %s %s\n", (int)event->event_type, event->timestamp, ((pushState_t)event->data)->type->id, ((pushState_t)event->data)->container->id, ((pushState_t)event->data)->value->id); } }else{ if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s %s ", (int)event->event_type, ((pushState_t)event->data)->type->id, ((pushState_t)event->data)->container->id, ((pushState_t)event->data)->value->id); if(((pushState_t)event->data)->extra !=NULL){ fprintf(tracing_file, "%d ", ((instr_extra_data)((pushState_t)event->data)->extra)->send_size); }else{ fprintf(tracing_file, "0 "); } fprintf(tracing_file, "\n"); }else{ fprintf(tracing_file, "%d %f %s %s %s ", (int)event->event_type, event->timestamp, ((pushState_t)event->data)->type->id, ((pushState_t)event->data)->container->id, ((pushState_t)event->data)->value->id); if(((pushState_t)event->data)->extra !=NULL){ fprintf(tracing_file, "%d ", ((instr_extra_data)((pushState_t)event->data)->extra)->send_size); }else{ fprintf(tracing_file, "0 "); } fprintf(tracing_file, "\n"); } } if(((pushState_t)event->data)->extra!=NULL){ if(((instr_extra_data)((pushState_t)event->data)->extra)->sendcounts!=NULL) xbt_free(((instr_extra_data)((pushState_t)event->data)->extra)->sendcounts); if(((instr_extra_data)((pushState_t)event->data)->extra)->recvcounts!=NULL) xbt_free(((instr_extra_data)((pushState_t)event->data)->extra)->recvcounts); xbt_free(((pushState_t)event->data)->extra); } } void print_pajePopState(paje_event_t event) { XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s\n", (int)event->event_type, ((popState_t)event->data)->type->id, ((popState_t)event->data)->container->id); }else{ fprintf(tracing_file, "%d %f %s %s\n", (int)event->event_type, event->timestamp, ((popState_t)event->data)->type->id, ((popState_t)event->data)->container->id); } } void print_pajeResetState(paje_event_t event) { XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s\n", (int)event->event_type, ((resetState_t)event->data)->type->id, ((resetState_t)event->data)->container->id); }else{ fprintf(tracing_file, "%d %f %s %s\n", (int)event->event_type, event->timestamp, ((resetState_t)event->data)->type->id, ((resetState_t)event->data)->container->id); } } void print_pajeStartLink(paje_event_t event) { if (!TRACE_display_sizes()){ if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s %s %s %s\n", (int)event->event_type, ((startLink_t)event->data)->type->id, ((startLink_t)event->data)->container->id, ((startLink_t)event->data)->value, ((startLink_t)event->data)->sourceContainer->id, ((startLink_t)event->data)->key); }else { fprintf(tracing_file, "%d %f %s %s %s %s %s\n", (int)event->event_type, event->timestamp, ((startLink_t)event->data)->type->id, ((startLink_t)event->data)->container->id, ((startLink_t)event->data)->value, ((startLink_t)event->data)->sourceContainer->id, ((startLink_t)event->data)->key); } }else{ XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s %s %s %s %d\n", (int)event->event_type, ((startLink_t)event->data)->type->id, ((startLink_t)event->data)->container->id, ((startLink_t)event->data)->value, ((startLink_t)event->data)->sourceContainer->id, ((startLink_t)event->data)->key, ((startLink_t)event->data)->size); }else { fprintf(tracing_file, "%d %f %s %s %s %s %s %d\n", (int)event->event_type, event->timestamp, ((startLink_t)event->data)->type->id, ((startLink_t)event->data)->container->id, ((startLink_t)event->data)->value, ((startLink_t)event->data)->sourceContainer->id, ((startLink_t)event->data)->key, ((startLink_t)event->data)->size); } } } void print_pajeEndLink(paje_event_t event) { XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s %s %s %s\n", (int)event->event_type, ((endLink_t)event->data)->type->id, ((endLink_t)event->data)->container->id, ((endLink_t)event->data)->value, ((endLink_t)event->data)->destContainer->id, ((endLink_t)event->data)->key); }else { fprintf(tracing_file, "%d %f %s %s %s %s %s\n", (int)event->event_type, event->timestamp, ((endLink_t)event->data)->type->id, ((endLink_t)event->data)->container->id, ((endLink_t)event->data)->value, ((endLink_t)event->data)->destContainer->id, ((endLink_t)event->data)->key); } } void print_pajeNewEvent (paje_event_t event) { XBT_DEBUG("%s: event_type=%d, timestamp=%f", __FUNCTION__, (int)event->event_type, event->timestamp); if (event->timestamp == 0){ fprintf(tracing_file, "%d 0 %s %s %s\n", (int)event->event_type, ((newEvent_t)event->data)->type->id, ((newEvent_t)event->data)->container->id, ((newEvent_t)event->data)->value->id); }else{ fprintf(tracing_file, "%d %f %s %s %s\n", (int)event->event_type, event->timestamp, ((newEvent_t)event->data)->type->id, ((newEvent_t)event->data)->container->id, ((newEvent_t)event->data)->value->id); } } SimGrid-3.11/src/instr/instr_paje_values.c000644 001750 001750 00000004154 12342443651 017643 0ustar00cici000000 000000 /* Copyright (c) 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "instr/instr_private.h" #ifdef HAVE_TRACING XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_paje_values, instr, "Paje tracing event system (values)"); val_t PJ_value_new (const char *name, const char *color, type_t father) { if (name == NULL || father == NULL){ THROWF (tracing_error, 0, "can't create a value with a NULL name (or a NULL father)"); } val_t ret = xbt_new0(s_val_t, 1); ret->name = xbt_strdup (name); ret->father = father; ret->color = xbt_strdup (color); char str_id[INSTR_DEFAULT_STR_SIZE]; snprintf (str_id, INSTR_DEFAULT_STR_SIZE, "%lld", instr_new_paje_id()); ret->id = xbt_strdup (str_id); xbt_dict_set (father->values, name, ret, NULL); XBT_DEBUG("new value %s, child of %s", ret->name, ret->father->name); new_pajeDefineEntityValue(ret); return ret; } val_t PJ_value_get_or_new (const char *name, const char *color, type_t father) { val_t ret = 0; xbt_ex_t e; TRY { ret = PJ_value_get(name, father); } CATCH(e) { xbt_ex_free(e); ret = PJ_value_new(name, color, father); } return ret; } val_t PJ_value_get (const char *name, type_t father) { if (name == NULL || father == NULL){ THROWF (tracing_error, 0, "can't get a value with a NULL name (or a NULL father)"); } if (father->kind == TYPE_VARIABLE) THROWF(tracing_error, 0, "variables can't have different values (%s)", father->name); val_t ret = (val_t)xbt_dict_get_or_null (father->values, name); if (ret == NULL) { THROWF(tracing_error, 2, "value with name (%s) not found in father type (%s)", name, father->name); } return ret; } void PJ_value_free (val_t value) { XBT_DEBUG("free value %s, child of %s", value->name, value->father->name); xbt_free(((val_t)value)->name); xbt_free(((val_t)value)->color); xbt_free(((val_t)value)->id); xbt_free(value); } #endif SimGrid-3.11/src/instr/instr_private.h000644 001750 001750 00000034376 12342443651 017035 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef INSTR_PRIVATE_H_ #define INSTR_PRIVATE_H_ #include "instr/instr.h" #include "instr/instr_interface.h" #include "internal_config.h" #include "simgrid_config.h" #ifdef HAVE_TRACING SG_BEGIN_DECL() /* Need to define function drand48 for Windows */ /* FIXME: use _drand48() defined in src/surf/random_mgr.c instead */ #ifdef _WIN32 # define drand48() (rand()/(RAND_MAX + 1.0)) #endif #define INSTR_DEFAULT_STR_SIZE 500 #include "xbt/graph.h" #include "xbt/dict.h" #include "simgrid/platf.h" typedef enum { PAJE_DefineContainerType, PAJE_DefineVariableType, PAJE_DefineStateType, PAJE_DefineEventType, PAJE_DefineLinkType, PAJE_DefineEntityValue, PAJE_CreateContainer, PAJE_DestroyContainer, PAJE_SetVariable, PAJE_AddVariable, PAJE_SubVariable, PAJE_SetState, PAJE_PushState, PAJE_PopState, PAJE_ResetState, PAJE_StartLink, PAJE_EndLink, PAJE_NewEvent } e_event_type; typedef enum { TYPE_VARIABLE, TYPE_LINK, TYPE_CONTAINER, TYPE_STATE, TYPE_EVENT } e_entity_types; typedef struct s_type *type_t; typedef struct s_type { char *id; char *name; char *color; e_entity_types kind; struct s_type *father; xbt_dict_t children; xbt_dict_t values; //valid for all types except variable and container }s_type_t; typedef struct s_val *val_t; typedef struct s_val { char *id; char *name; char *color; type_t father; }s_val_t; typedef enum { INSTR_HOST, INSTR_LINK, INSTR_ROUTER, INSTR_AS, INSTR_SMPI, INSTR_MSG_VM, INSTR_MSG_PROCESS, INSTR_MSG_TASK } e_container_types; typedef struct s_container *container_t; typedef struct s_container { sg_routing_edge_t net_elm; char *name; /* Unique name of this container */ char *id; /* Unique id of this container */ type_t type; /* Type of this container */ int level; /* Level in the hierarchy, root level is 0 */ e_container_types kind; /* This container is of what kind */ struct s_container *father; xbt_dict_t children; }s_container_t; typedef struct paje_event *paje_event_t; typedef struct paje_event { double timestamp; e_event_type event_type; void (*print) (paje_event_t event); void (*free) (paje_event_t event); void *data; } s_paje_event_t; typedef struct s_defineContainerType *defineContainerType_t; typedef struct s_defineContainerType { type_t type; }s_defineContainerType_t; typedef struct s_defineVariableType *defineVariableType_t; typedef struct s_defineVariableType { type_t type; }s_defineVariableType_t; typedef struct s_defineStateType *defineStateType_t; typedef struct s_defineStateType { type_t type; }s_defineStateType_t; typedef struct s_defineEventType *defineEventType_t; typedef struct s_defineEventType { type_t type; }s_defineEventType_t; typedef struct s_defineLinkType *defineLinkType_t; typedef struct s_defineLinkType { type_t type; type_t source; type_t dest; }s_defineLinkType_t; typedef struct s_defineEntityValue *defineEntityValue_t; typedef struct s_defineEntityValue { val_t value; }s_defineEntityValue_t; typedef struct s_createContainer *createContainer_t; typedef struct s_createContainer { container_t container; }s_createContainer_t; typedef struct s_destroyContainer *destroyContainer_t; typedef struct s_destroyContainer { container_t container; }s_destroyContainer_t; typedef struct s_setVariable *setVariable_t; typedef struct s_setVariable { container_t container; type_t type; double value; }s_setVariable_t; typedef struct s_addVariable *addVariable_t; typedef struct s_addVariable { container_t container; type_t type; double value; }s_addVariable_t; typedef struct s_subVariable *subVariable_t; typedef struct s_subVariable { container_t container; type_t type; double value; }s_subVariable_t; typedef struct s_setState *setState_t; typedef struct s_setState { container_t container; type_t type; val_t value; }s_setState_t; typedef struct s_pushState *pushState_t; typedef struct s_pushState { container_t container; type_t type; val_t value; int size; void* extra; }s_pushState_t; typedef struct s_popState *popState_t; typedef struct s_popState { container_t container; type_t type; xbt_dynar_t extra; }s_popState_t; typedef struct s_resetState *resetState_t; typedef struct s_resetState { container_t container; type_t type; }s_resetState_t; typedef struct s_startLink *startLink_t; typedef struct s_startLink { container_t container; type_t type; container_t sourceContainer; char *value; char *key; int size; }s_startLink_t; typedef struct s_endLink *endLink_t; typedef struct s_endLink { container_t container; type_t type; container_t destContainer; char *value; char *key; }s_endLink_t; typedef struct s_newEvent *newEvent_t; typedef struct s_newEvent { container_t container; type_t type; val_t value; }s_newEvent_t; extern xbt_dict_t created_categories; extern xbt_dict_t declared_marks; extern xbt_dict_t user_host_variables; extern xbt_dict_t user_vm_variables; extern xbt_dict_t user_link_variables; extern double TRACE_last_timestamp_to_dump; /* instr_paje_header.c */ void TRACE_header(int basic, int size); /* from paje.c */ void TRACE_init(void); void TRACE_finalize(void); void TRACE_paje_init(void); void TRACE_paje_start(void); void TRACE_paje_end(void); void TRACE_paje_dump_buffer (int force); XBT_PUBLIC(void) new_pajeDefineContainerType(type_t type); XBT_PUBLIC(void) new_pajeDefineVariableType(type_t type); XBT_PUBLIC(void) new_pajeDefineStateType(type_t type); XBT_PUBLIC(void) new_pajeDefineEventType(type_t type); XBT_PUBLIC(void) new_pajeDefineLinkType(type_t type, type_t source, type_t dest); XBT_PUBLIC(void) new_pajeDefineEntityValue (val_t type); XBT_PUBLIC(void) new_pajeCreateContainer (container_t container); XBT_PUBLIC(void) new_pajeDestroyContainer (container_t container); XBT_PUBLIC(void) new_pajeSetVariable (double timestamp, container_t container, type_t type, double value); XBT_PUBLIC(void) new_pajeAddVariable (double timestamp, container_t container, type_t type, double value); XBT_PUBLIC(void) new_pajeSubVariable (double timestamp, container_t container, type_t type, double value); XBT_PUBLIC(void) new_pajeSetState (double timestamp, container_t container, type_t type, val_t value); XBT_PUBLIC(void) new_pajePushState (double timestamp, container_t container, type_t type, val_t value); XBT_PUBLIC(void) new_pajePushStateWithExtra (double timestamp, container_t container, type_t type, val_t value, void* extra); XBT_PUBLIC(void) new_pajePopState (double timestamp, container_t container, type_t type); XBT_PUBLIC(void) new_pajeResetState (double timestamp, container_t container, type_t type); XBT_PUBLIC(void) new_pajeStartLink (double timestamp, container_t container, type_t type, container_t sourceContainer, const char *value, const char *key); XBT_PUBLIC(void) new_pajeStartLinkWithSize (double timestamp, container_t container, type_t type, container_t sourceContainer, const char *value, const char *key, int size); XBT_PUBLIC(void) new_pajeEndLink (double timestamp, container_t container, type_t type, container_t destContainer, const char *value, const char *key); XBT_PUBLIC(void) new_pajeNewEvent (double timestamp, container_t container, type_t type, val_t value); //for tracing gtnets void TRACE_surf_gtnets_communicate(void *action, void *src, void *dst); /* from instr_config.c */ int TRACE_needs_platform (void); int TRACE_is_enabled(void); int TRACE_platform(void); int TRACE_platform_topology(void); int TRACE_is_configured(void); int TRACE_categorized (void); int TRACE_uncategorized (void); int TRACE_msg_process_is_enabled(void); int TRACE_msg_vm_is_enabled(void); int TRACE_buffer (void); int TRACE_disable_link(void); int TRACE_disable_power(void); int TRACE_onelink_only (void); int TRACE_disable_destroy (void); int TRACE_basic (void); int TRACE_display_sizes (void); char *TRACE_get_comment (void); char *TRACE_get_comment_file (void); char *TRACE_get_filename(void); char *TRACE_get_viva_uncat_conf (void); char *TRACE_get_viva_cat_conf (void); void TRACE_generate_viva_uncat_conf (void); void TRACE_generate_viva_cat_conf (void); void instr_pause_tracing (void); void instr_resume_tracing (void); /* Public functions used in SMPI */ XBT_PUBLIC(int) TRACE_smpi_is_enabled(void); XBT_PUBLIC(int) TRACE_smpi_is_grouped(void); XBT_PUBLIC(int) TRACE_smpi_is_computing(void); XBT_PUBLIC(int) TRACE_smpi_is_sleeping(void); XBT_PUBLIC(int) TRACE_smpi_view_internals(void); /* from resource_utilization.c */ void TRACE_surf_host_set_utilization(const char *resource, const char *category, double value, double now, double delta); void TRACE_surf_link_set_utilization(const char *resource, const char *category, double value, double now, double delta); void TRACE_surf_resource_utilization_alloc(void); /* instr_paje.c */ extern xbt_dict_t trivaNodeTypes; extern xbt_dict_t trivaEdgeTypes; long long int instr_new_paje_id (void); void PJ_container_alloc (void); void PJ_container_release (void); XBT_PUBLIC(container_t) PJ_container_new (const char *name, e_container_types kind, container_t father); XBT_PUBLIC(container_t) PJ_container_get (const char *name); XBT_PUBLIC(container_t) PJ_container_get_or_null (const char *name); XBT_PUBLIC(container_t) PJ_container_get_root (void); XBT_PUBLIC(void) PJ_container_set_root (container_t root); XBT_PUBLIC(void) PJ_container_free (container_t container); XBT_PUBLIC(void) PJ_container_free_all (void); XBT_PUBLIC(void) PJ_container_remove_from_parent (container_t container); /* instr_paje_types.c */ void PJ_type_alloc (void); void PJ_type_release (void); XBT_PUBLIC(type_t) PJ_type_get_root (void); type_t PJ_type_container_new (const char *name, type_t father); type_t PJ_type_event_new (const char *name, type_t father); type_t PJ_type_variable_new (const char *name, const char *color, type_t father); type_t PJ_type_link_new (const char *name, type_t father, type_t source, type_t dest); type_t PJ_type_state_new (const char *name, type_t father); XBT_PUBLIC(type_t) PJ_type_get (const char *name, const type_t father); XBT_PUBLIC(type_t) PJ_type_get_or_null (const char *name, type_t father); void PJ_type_free (type_t type); void PJ_type_free_all (void); /* instr_paje_values.c */ XBT_PUBLIC(val_t) PJ_value_new (const char *name, const char *color, type_t father); XBT_PUBLIC(val_t) PJ_value_get_or_new (const char *name, const char *color, type_t father); XBT_PUBLIC(val_t) PJ_value_get (const char *name, const type_t father); void PJ_value_free (val_t value); void print_pajeDefineContainerType(paje_event_t event); void print_pajeDefineVariableType(paje_event_t event); void print_pajeDefineStateType(paje_event_t event); void print_pajeDefineEventType(paje_event_t event); void print_pajeDefineLinkType(paje_event_t event); void print_pajeDefineEntityValue (paje_event_t event); void print_pajeCreateContainer(paje_event_t event); void print_pajeDestroyContainer(paje_event_t event); void print_pajeSetVariable(paje_event_t event); void print_pajeAddVariable(paje_event_t event); void print_pajeSubVariable(paje_event_t event); void print_pajeSetState(paje_event_t event); void print_pajePushState(paje_event_t event); void print_pajePopState(paje_event_t event); void print_pajeResetState(paje_event_t event); void print_pajeStartLink(paje_event_t event); void print_pajeEndLink(paje_event_t event); void print_pajeNewEvent (paje_event_t event); void print_TIPushState(paje_event_t event); void print_TICreateContainer(paje_event_t event); void print_TIDestroyContainer(paje_event_t event); void TRACE_TI_start(void); void TRACE_TI_end(void); void TRACE_TI_init(void); void print_NULL (paje_event_t event); void TRACE_paje_dump_buffer (int force); void dump_comment_file (const char *filename); void dump_comment (const char *comment); typedef struct instr_trace_writer { void (*print_DefineContainerType) (paje_event_t event); void (*print_DefineVariableType)(paje_event_t event); void (*print_DefineStateType)(paje_event_t event); void (*print_DefineEventType)(paje_event_t event); void (*print_DefineLinkType)(paje_event_t event); void (*print_DefineEntityValue)(paje_event_t event); void (*print_CreateContainer)(paje_event_t event); void (*print_DestroyContainer)(paje_event_t event); void (*print_SetVariable)(paje_event_t event); void (*print_AddVariable)(paje_event_t event); void (*print_SubVariable)(paje_event_t event); void (*print_SetState)(paje_event_t event); void (*print_PushState)(paje_event_t event); void (*print_PopState)(paje_event_t event); void (*print_ResetState)(paje_event_t event); void (*print_StartLink)(paje_event_t event); void (*print_EndLink)(paje_event_t event); void (*print_NewEvent) (paje_event_t event); } s_instr_trace_writer_t; struct s_instr_extra_data; typedef struct s_instr_extra_data *instr_extra_data; typedef enum{ TRACING_INIT, TRACING_FINALIZE, TRACING_COMM_SIZE, TRACING_COMM_SPLIT, TRACING_COMM_DUP, TRACING_SEND, TRACING_ISEND, TRACING_SSEND, TRACING_ISSEND, TRACING_RECV, TRACING_IRECV, TRACING_SENDRECV, TRACING_TEST, TRACING_WAIT, TRACING_WAITALL, TRACING_WAITANY, TRACING_BARRIER, TRACING_BCAST, TRACING_REDUCE, TRACING_ALLREDUCE, TRACING_ALLTOALL, TRACING_ALLTOALLV, TRACING_GATHER, TRACING_GATHERV, TRACING_SCATTER, TRACING_SCATTERV, TRACING_ALLGATHER, TRACING_ALLGATHERV, TRACING_REDUCE_SCATTER, TRACING_COMPUTING, TRACING_SLEEPING, TRACING_SCAN, TRACING_EXSCAN } e_caller_type ; typedef struct s_instr_extra_data { e_caller_type type; int send_size; int recv_size; double comp_size; double sleep_duration; int src; int dst; int root; const char* datatype1; const char* datatype2; int * sendcounts; int * recvcounts; int num_processes; } s_instr_extra_data_t; SG_END_DECL() #endif /* HAVE_TRACING */ #ifdef HAVE_JEDULE #include "instr/jedule/jedule_sd_binding.h" #endif #endif /* INSTR_PRIVATE_H_ */ SimGrid-3.11/src/instr/jedule/000755 001750 001750 00000000000 12342443653 015230 5ustar00cici000000 000000 SimGrid-3.11/src/instr/jedule/jedule_sd_binding.c000644 001750 001750 00000006657 12342443653 021042 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "xbt/asserts.h" #include "xbt/dynar.h" #include "surf/surf_private.h" #include "surf/surf_resource.h" #include "surf/surf.h" #include "instr/jedule/jedule_sd_binding.h" #include "instr/jedule/jedule_events.h" #include "instr/jedule/jedule_platform.h" #include "instr/jedule/jedule_output.h" #include "simdag/private.h" #include #ifdef HAVE_JEDULE XBT_LOG_NEW_CATEGORY(jedule, "Logging specific to Jedule"); XBT_LOG_NEW_DEFAULT_SUBCATEGORY(jed_sd, jedule, "Logging specific to Jedule SD binding"); jedule_t jedule; void jedule_log_sd_event(SD_task_t task) { xbt_dynar_t host_list; jed_event_t event; int i; xbt_assert(task != NULL); host_list = xbt_dynar_new(sizeof(char*), NULL); for(i=0; iworkstation_nb; i++) { char *hostname = sg_host_name(task->workstation_list[i]); xbt_dynar_push(host_list, &hostname); } create_jed_event(&event, (char*)SD_task_get_name(task), task->start_time, task->finish_time, "SD"); jed_event_add_resources(event, host_list); jedule_store_event(event); xbt_dynar_free(&host_list); } static void create_hierarchy(AS_t current_comp, jed_simgrid_container_t current_container) { xbt_dict_cursor_t cursor = NULL; char *key; AS_t elem; xbt_dict_t routing_sons = surf_AS_get_routing_sons(current_comp); if (xbt_dict_is_empty(routing_sons)) { // I am no AS // add hosts to jedule platform xbt_dynar_t table = surf_AS_get_hosts(current_comp); xbt_dynar_t hosts; unsigned int dynar_cursor; sg_host_t host_elem; hosts = xbt_dynar_new(sizeof(char*), NULL); xbt_dynar_foreach(table, dynar_cursor, host_elem) { xbt_dynar_push_as(hosts, char*, sg_host_name(host_elem)); } jed_simgrid_add_resources(current_container, hosts); xbt_dynar_free(&hosts); xbt_dynar_free(&table); } else { xbt_dict_foreach(routing_sons, cursor, key, elem) { jed_simgrid_container_t child_container; jed_simgrid_create_container(&child_container, surf_AS_get_name(elem)); jed_simgrid_add_container(current_container, child_container); XBT_DEBUG("name : %s\n", surf_AS_get_name(elem)); create_hierarchy(elem, child_container); } } } void jedule_setup_platform() { AS_t root_comp; // e_surf_network_element_type_t type; jed_simgrid_container_t root_container; jed_create_jedule(&jedule); root_comp = surf_AS_get_routing_root(); XBT_DEBUG("root name %s\n", surf_AS_get_name(root_comp)); jed_simgrid_create_container(&root_container, surf_AS_get_name(root_comp)); jedule->root_container = root_container; create_hierarchy(root_comp, root_container); } void jedule_sd_cleanup() { jedule_cleanup_output(); } void jedule_sd_init() { jedule_init_output(); } void jedule_sd_exit(void) { if (jedule) { jed_free_jedule(jedule); jedule = NULL; } } void jedule_sd_dump() { if (jedule) { FILE *fh; char fname[1024]; fname[0] = '\0'; strcat(fname, xbt_binary_name); strcat(fname, ".jed\0"); fh = fopen(fname, "w"); write_jedule_output(fh, jedule, jedule_event_list, NULL); fclose(fh); } } #endif SimGrid-3.11/src/instr/jedule/jedule_events.c000644 001750 001750 00000004164 12342443653 020235 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include #include "xbt/dict.h" #include "xbt/dynar.h" #include "xbt/asserts.h" #include "instr/jedule/jedule_events.h" #include "instr/jedule/jedule_platform.h" #ifdef HAVE_JEDULE void jed_event_add_resources(jed_event_t event, xbt_dynar_t host_selection) { xbt_dynar_t resource_subset_list; jed_res_subset_t res_set; unsigned int i; resource_subset_list = xbt_dynar_new(sizeof(jed_res_subset_t), NULL); jed_simgrid_get_resource_selection_by_hosts(resource_subset_list, host_selection); xbt_dynar_foreach(resource_subset_list, i, res_set) { xbt_dynar_push(event->resource_subsets, &res_set); } xbt_dynar_free(&resource_subset_list); } void jed_event_add_characteristic(jed_event_t event, char *characteristic) { xbt_assert( characteristic != NULL ); xbt_dynar_push(event->characteristics_list, &characteristic); } void jed_event_add_info(jed_event_t event, char *key, char *value) { char *val_cp; xbt_assert(key != NULL); xbt_assert(value != NULL); val_cp = strdup(value); xbt_dict_set(event->info_hash, key, val_cp, NULL); } void create_jed_event(jed_event_t *event, char *name, double start_time, double end_time, const char *type) { *event = xbt_new0(s_jed_event_t,1); (*event)->name = xbt_strdup(name); (*event)->start_time = start_time; (*event)->end_time = end_time; (*event)->type = xbt_strdup(type); (*event)->resource_subsets = xbt_dynar_new(sizeof(jed_res_subset_t), xbt_free_ref); (*event)->characteristics_list = xbt_dynar_new(sizeof(char*), NULL); (*event)->info_hash = xbt_dict_new_homogeneous(NULL); } void jed_event_free(jed_event_t event) { free(event->name); free(event->type); xbt_dynar_free(&event->resource_subsets); xbt_dynar_free(&event->characteristics_list); xbt_dict_free(&event->info_hash); free(event); } #endif SimGrid-3.11/src/instr/jedule/jedule_platform.c000644 001750 001750 00000016574 12342443653 020565 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "xbt/asserts.h" #include "xbt/dynar.h" #include "instr/jedule/jedule_platform.h" #ifdef HAVE_JEDULE /********************************************************************/ static xbt_dict_t host2_simgrid_parent_container; static xbt_dict_t container_name2container; /********************************************************************/ static void add_subset_to(xbt_dynar_t subset_list, int start, int end, jed_simgrid_container_t parent); static void add_subsets_to(xbt_dynar_t subset_list, xbt_dynar_t hostgroup, jed_simgrid_container_t parent); static void jed_free_container(jed_simgrid_container_t container); /********************************************************************/ static int compare_hostnames(const void *host1, const void *host2) { const char *hp1 = *((const char**) host1); const char *hp2 = *((const char**) host2); return strcmp (hp1, hp2); } static int compare_ids(const void *num1, const void *num2) { int *i1 = (int*) num1; int *i2 = (int*) num2; return *i1 - *i2; } static void jed_free_container(jed_simgrid_container_t container) { xbt_dict_free(&container->name2id); xbt_dynar_free(&container->resource_list); if( container->container_children != NULL ) { unsigned int iter; jed_simgrid_container_t child_container; xbt_dynar_foreach(container->container_children, iter, child_container) { jed_free_container(child_container); } xbt_dynar_free(&container->container_children); } xbt_free(container->name); xbt_free(container); } void jed_simgrid_create_container(jed_simgrid_container_t *container, const char *name) { xbt_assert( name != NULL ); *container = xbt_new0(s_jed_simgrid_container_t,1); (*container)->name = xbt_strdup(name); (*container)->is_lowest = 0; (*container)->container_children = xbt_dynar_new(sizeof(jed_simgrid_container_t), NULL); (*container)->parent = NULL; xbt_dict_set(container_name2container, (*container)->name, *container, NULL); } void jed_simgrid_add_container(jed_simgrid_container_t parent, jed_simgrid_container_t child) { xbt_assert(parent != NULL); xbt_assert(child != NULL); xbt_dynar_push(parent->container_children, &child); child->parent = parent; } void jed_simgrid_add_resources(jed_simgrid_container_t parent, xbt_dynar_t host_names) { unsigned int iter; char *host_name; char *buf; parent->is_lowest = 1; xbt_dynar_free(&parent->container_children); parent->container_children = NULL; parent->name2id = xbt_dict_new_homogeneous(xbt_free); parent->last_id = 0; parent->resource_list = xbt_dynar_new(sizeof(char *), NULL); xbt_dynar_sort (host_names, &compare_hostnames); xbt_dynar_foreach(host_names, iter, host_name) { buf = bprintf("%d", parent->last_id); (parent->last_id)++; xbt_dict_set(parent->name2id, host_name, buf, NULL); xbt_dict_set(host2_simgrid_parent_container, host_name, parent, NULL); xbt_dynar_push(parent->resource_list, &host_name); } } static void add_subset_to(xbt_dynar_t subset_list, int start, int end, jed_simgrid_container_t parent) { jed_res_subset_t subset; xbt_assert( subset_list != NULL ); xbt_assert( parent != NULL ); // printf(">>> start=%d end=%d\n", start, end); subset = xbt_new0(s_jed_res_subset_t,1); subset->start_idx = start; subset->nres = end-start+1; subset->parent = parent; xbt_dynar_push(subset_list, &subset); } static void add_subsets_to(xbt_dynar_t subset_list, xbt_dynar_t hostgroup, jed_simgrid_container_t parent) { unsigned int iter; char *host_name; xbt_dynar_t id_list; int *id_ar; int nb_ids; char *id_str; // get ids for each host // sort ids // compact ids // create subset for each id group xbt_assert( host2_simgrid_parent_container != NULL ); xbt_assert( subset_list != NULL ); xbt_assert( hostgroup != NULL ); xbt_assert( parent != NULL ); id_list = xbt_dynar_new(sizeof(char *), NULL); xbt_dynar_foreach(hostgroup, iter, host_name) { jed_simgrid_container_t parent; xbt_assert( host_name != NULL ); parent = xbt_dict_get(host2_simgrid_parent_container, host_name); id_str = xbt_dict_get(parent->name2id, host_name); xbt_dynar_push(id_list, &id_str); } nb_ids = xbt_dynar_length(id_list); id_ar = xbt_new0(int,nb_ids); xbt_dynar_foreach(id_list, iter, id_str) { id_ar[iter] = atoi(id_str); } qsort (id_ar, nb_ids, sizeof(int), &compare_ids); if( nb_ids > 0 ) { int start = 0; int pos; int i; pos = start; for(i=0; i 1 ) { add_subset_to( subset_list, id_ar[start], id_ar[pos], parent ); start = i; if( i == nb_ids-1 ) { add_subset_to( subset_list, id_ar[i], id_ar[i], parent ); } } else { if( i == nb_ids-1 ) { add_subset_to( subset_list, id_ar[start], id_ar[i], parent ); } } pos = i; } } free(id_ar); xbt_dynar_free(&id_list); } void jed_simgrid_get_resource_selection_by_hosts(xbt_dynar_t subset_list, xbt_dynar_t host_names) { char *host_name; unsigned int iter; xbt_dict_t parent2hostgroup; // group hosts by parent parent2hostgroup = xbt_dict_new_homogeneous(NULL); xbt_assert( host_names != NULL ); // for each host name // find parent container // group by parent container xbt_dynar_foreach(host_names, iter, host_name) { jed_simgrid_container_t parent; xbt_dynar_t hostgroup; //printf("checking %s \n", host_name); parent = xbt_dict_get(host2_simgrid_parent_container, host_name); xbt_assert( parent != NULL ); hostgroup = xbt_dict_get_or_null (parent2hostgroup, parent->name); if( hostgroup == NULL ) { hostgroup = xbt_dynar_new(sizeof(char*), NULL); xbt_dict_set(parent2hostgroup, parent->name, hostgroup, NULL); } xbt_dynar_push(hostgroup, &host_name); } { xbt_dict_cursor_t cursor=NULL; char *parent_name; xbt_dynar_t hostgroup; jed_simgrid_container_t parent; xbt_dict_foreach(parent2hostgroup,cursor,parent_name,hostgroup) { parent = xbt_dict_get(container_name2container, parent_name); // printf("subset parent >>> %s\n", parent->name); add_subsets_to(subset_list, hostgroup, parent); } xbt_dynar_free(&hostgroup); } xbt_dict_free(&parent2hostgroup); } void jedule_add_meta_info(jedule_t jedule, char *key, char *value) { char *val_cp; xbt_assert(key != NULL); xbt_assert(value != NULL); val_cp = strdup(value); xbt_dict_set(jedule->jedule_meta_info, key, val_cp, NULL); } void jed_create_jedule(jedule_t *jedule) { *jedule = xbt_new0(s_jedule_t,1); host2_simgrid_parent_container = xbt_dict_new_homogeneous(NULL); container_name2container = xbt_dict_new_homogeneous(NULL); (*jedule)->jedule_meta_info = xbt_dict_new_homogeneous(NULL); } void jed_free_jedule(jedule_t jedule) { jed_free_container(jedule->root_container); xbt_dict_free(&jedule->jedule_meta_info); xbt_free(jedule); xbt_dict_free(&host2_simgrid_parent_container); xbt_dict_free(&container_name2container); } #endif SimGrid-3.11/src/instr/jedule/jedule_output.c000644 001750 001750 00000015156 12342443653 020274 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include #include "xbt/dynar.h" #include "xbt/asserts.h" #include "instr/jedule/jedule_output.h" #ifdef HAVE_JEDULE XBT_LOG_NEW_DEFAULT_SUBCATEGORY(jed_out, jedule, "Logging specific to Jedule output"); /*********************************************************/ xbt_dynar_t jedule_event_list; static FILE *jed_file; static void print_platform(jed_simgrid_container_t root_container); static void print_container(jed_simgrid_container_t container); static void print_resources(jed_simgrid_container_t resource_parent); static void print_key_value_dict(xbt_dict_t meta_info_dict); static void print_events(xbt_dynar_t event_list); static void get_hierarchy_list(xbt_dynar_t hier_list, jed_simgrid_container_t container); /*********************************************************/ static void get_hierarchy_list(xbt_dynar_t hier_list, jed_simgrid_container_t container) { xbt_assert( container != NULL ); if( container->parent != NULL ) { if( container->parent->container_children == NULL ) { // we are in the last level get_hierarchy_list(hier_list, container->parent); } else { unsigned int i; int child_nb = -1; jed_simgrid_container_t child_container; xbt_dynar_foreach(container->parent->container_children, i, child_container) { if( child_container == container ) { child_nb = i; break; } } xbt_assert( child_nb > - 1); xbt_dynar_insert_at(hier_list, 0, &child_nb); get_hierarchy_list(hier_list, container->parent); } } else { int top_level = 0; xbt_dynar_insert_at(hier_list, 0, &top_level); } } static void get_hierarchy_string(jed_simgrid_container_t container, char *outbuf) { char buf[1024]; xbt_dynar_t hier_list; unsigned int iter; int number; int length; outbuf[0] = '\0'; hier_list = xbt_dynar_new(sizeof(int), NULL); get_hierarchy_list(hier_list, container); length = xbt_dynar_length(hier_list); xbt_dynar_foreach(hier_list, iter, number) { if( iter != length-1 ) { sprintf(buf, "%d.", number); } else { sprintf(buf, "%d", number); } strcat(outbuf, buf); } xbt_dynar_free(&hier_list); } static void print_key_value_dict(xbt_dict_t key_value_dict) { xbt_dict_cursor_t cursor=NULL; char *key,*data; if( key_value_dict != NULL ) { xbt_dict_foreach(key_value_dict,cursor,key,data) { fprintf(jed_file, "\n",key,data); } } } static void print_container(jed_simgrid_container_t container) { unsigned int i; jed_simgrid_container_t child_container; xbt_assert( container != NULL ); fprintf(jed_file, "\n", container->name); if( container->container_children != NULL ) { xbt_dynar_foreach(container->container_children, i, child_container) { print_container(child_container); } } else { print_resources(container); } fprintf(jed_file, "\n"); } static void print_resources(jed_simgrid_container_t resource_parent) { int res_nb; unsigned int i; char *res_name; char resid[1024]; xbt_assert( resource_parent->resource_list != NULL ); res_nb = xbt_dynar_length(resource_parent->resource_list); get_hierarchy_string(resource_parent, resid); fprintf(jed_file, "resource_list, i, res_name) { fprintf(jed_file, "%s", res_name); if( i != res_nb-1 ) { fprintf(jed_file, "|"); } } fprintf(jed_file, "\" />\n"); } static void print_platform(jed_simgrid_container_t root_container) { fprintf(jed_file, "\n"); print_container(root_container); fprintf(jed_file, "\n"); } static void print_event(jed_event_t event) { unsigned int i; jed_res_subset_t subset; xbt_assert( event != NULL ); xbt_assert( event->resource_subsets != NULL ); fprintf(jed_file, "\n"); fprintf(jed_file, "\n", event->name); fprintf(jed_file, "\n", event->start_time); fprintf(jed_file, "\n", event->end_time); fprintf(jed_file, "\n", event->type); fprintf(jed_file, "\n"); xbt_dynar_foreach(event->resource_subsets, i, subset) { int start = subset->start_idx; int end = subset->start_idx + subset->nres - 1; char resid[1024]; get_hierarchy_string(subset->parent, resid); fprintf(jed_file, ")) { chomp $line; if($line =~ /^7\s/) { my($event,$date,$id,$type,$father,@name) = split(/\s+/,$line); $Cat{$id}{name}="@name "; $Cat{$id}{name}=~s/\"//g; $Cat{$id}{father}=$father; $Cat{$id}{type}=$type; $Cat{$id}{date}=$date; } } close INPUT; return \%Cat; } sub read_event { my($filename,$Cat)=@_; my($line); open INPUT, $filename; while (defined($line=)) { chomp $line; if($line =~ /^11\s/) { my($event,$date,$type,$id,$state) = split(/\s+/,$line); push @{$$Cat{$id}{state}}, [$date,$state]; } if($line =~ /^12\s/) { my($event,$date,$type,$id) = split(/\s+/,$line); push @{$$Cat{$id}{state}}, [$date]; } } close INPUT; } sub read_link { my($filename)=@_; my($line); my(%link); open INPUT, $filename; while (defined($line=)) { chomp $line; if($line =~ /^16\s/) { my($event,$date,$type,$father,$channel,$src,$key,$trash) = split(/\t+/,$line); my($numkey)=hex "$key"; while (defined($link{$numkey})) {$numkey++;} $link{$numkey}{src}=$src; $link{$numkey}{src_date}=$date; } if($line =~ /^17\s/) { my($event,$date,$type,$father,$channel,$dst,$key,$trash) = split(/\t+/,$line); my($numkey)=hex "$key"; while (defined($link{$numkey}{dst})) {$numkey++;} $link{$numkey}{dst}=$dst; $link{$numkey}{dst_date}=$date; } } close INPUT; return \%link; } sub build_cat_tree { my($root,$Cat)=@_; my(@childs)=(); my($cat); foreach $cat (keys %$Cat) { if($$Cat{$cat}{father} eq $root) { push @childs, build_cat_tree($cat,$Cat); } # print "$$Cat{$cat}{name}\t\t $Cat{$cat}{father}\n"; } return [$root,@childs]; } sub build_cat_list { my($tree,$cat_list)=@_; my($root) = shift @$tree; my($u); push @$cat_list,$root; foreach $u (@$tree) { build_cat_list($u,$cat_list); } unshift @$tree, $root; } sub cat_sorting_function { my($cat1,$cat2,$Cat)=@_; if (!defined($$Cat{$cat1}{state})) { if (!defined($$Cat{$cat2}{state})) { return 0; } else { return 1; } } if (!defined($$Cat{$cat2}{state})) { return -1; } my($comp) = $$Cat{$$Cat{$cat1}{'father'}}{'name'} cmp $$Cat{$$Cat{$cat2}{'father'}}{'name'}; if ($comp == 0) { return $$Cat{$cat1}{'name'} cmp $$Cat{$cat2}{'name'}; } else { return $comp; } } sub update_host_Y { my($host,$i) = @_; if (!defined($$host{'Y_min_host'})) { $$host{'Y_min_host'} = $i; } else { if ($$host{'Y_min_host'} > $i) { $$host{'Y_min_host'} = $i; } } if (!defined($$host{'Y_max_host'})) { $$host{'Y_max_host'} = $i+1; } else { if ($$host{'Y_max_host'} < $i+1) { $$host{'Y_max_host'} = $i+1; } } } sub set_cat_position { my($Cat,$cat_list)=@_; my($i)=0; my($cat); foreach $cat (sort {cat_sorting_function($a,$b,$Cat)} @$cat_list) { if(defined($$Cat{$cat}{state})) { update_host_Y($$Cat{$$Cat{$cat}{'father'}},$i); $$Cat{$cat}{Y_min} = $i; $$Cat{$cat}{Y_max} = $i+1; $i++; } } } sub create_fig { my($filename)=shift; my($fig)=new XFig; $fig->{object} = 'compound'; # Compound $fig->{elements} = []; $fig->{version} = 3.2; $fig->{orientation} = 'Landscape'; $fig->{justification} = 'Center'; $fig->{units} = 'Metric'; $fig->{papersize} = 'A4'; $fig->{magnification} = '100.00'; $fig->{multiplepage} = 'Single'; $fig->{transparent} = '-2'; $fig->{resolution} = '1200'; $fig->{coordsystem} = '2'; $fig->{filename} = $filename; return $fig; } sub draw_cat { my($fig,$Cat,$Link)=@_; my($cat,$e,$link); my($max_string_length)=0; foreach $cat (keys %$Cat) { next unless (defined($$Cat{$cat}{Y_min}) && defined($$Cat{$cat}{Y_max})); my($text) = new XFig ('text'); # $text->{'text'} = "$$Cat{$$Cat{$cat}{father}}{name}"."$$Cat{$cat}{name}"; my($printed_name)= $$Cat{$cat}{name}; $printed_name =~ s/\d+ \(0\)\s*$//; if (length($printed_name) > $max_string_length) { $max_string_length = length($printed_name); } $text->{'text'} = "$printed_name"; $text->{'y'} = ($$Cat{$cat}{Y_min}+$$Cat{$cat}{Y_max})/2*$grid_Y_size+68; $text->{'x'} = -100; $text->{'subtype'} = 2; $fig->add ($text); } my($max_date)=0; foreach $cat (keys %$Cat) { next unless (defined($$Cat{$cat}{Y_min}) && defined($$Cat{$cat}{Y_max})); my(@states)=(); my($e); foreach $e (@{$$Cat{$cat}{state}}) { my($new_date,$state) = ($$e[0],$$e[1]); if ($new_date > $max_date) { $max_date = $new_date; } if(defined($state)) { push @states, $e; } else { my($old_event) = pop @states; my($old_date) = $$old_event[0]; $state = $$old_event[1]; # LM: I added the next line because of "undefined values"... # normally, I think that this should not happen, but this part of code # is a bit too cryptic to me next unless (defined($state)); my($line) = new XFig ('polyline'); $line->{'depth'} = 50; # line $line->{'subtype'} = 1; # line $line->{'points'} = [ [$old_date*$grid_X_size, $$Cat{$cat}{Y_min}*$grid_Y_size], [$new_date*$grid_X_size, $$Cat{$cat}{Y_min}*$grid_Y_size], [$new_date*$grid_X_size, $$Cat{$cat}{Y_max}*$grid_Y_size], [$old_date*$grid_X_size, $$Cat{$cat}{Y_max}*$grid_Y_size], [$old_date*$grid_X_size, $$Cat{$cat}{Y_min}*$grid_Y_size] ]; $line->{'areafill'} = 20; if($state eq "S") { $line->{'fillcolor'} = $color_suspended; } elsif ($state eq "E") { $line->{'fillcolor'} = $color_compute; } elsif ($state eq "B") { $line->{'fillcolor'} = $color_wait_for_recpt; } elsif ($state eq "C") { $line->{'fillcolor'} = $color_communicate; } $fig->add ($line); } } } foreach $link (keys %$Link) { my($line) = new XFig ('polyline'); my($src_date)=$$Link{$link}{src_date}; my($src)=$$Link{$link}{src}; my($dst_date)=$$Link{$link}{dst_date}; my($dst)=$$Link{$link}{dst}; $line->{'subtype'} = 1; # line print STDERR "$link: $src ($src_date) -> $dst ($dst_date)\n"; print STDERR "$$Cat{$src}{name} -> $$Cat{$dst}{name}\n"; $line->{'points'} = [ [$src_date*$grid_X_size, ($$Cat{$src}{Y_min}+$$Cat{$src}{Y_max})/2*$grid_Y_size], [$dst_date*$grid_X_size, ($$Cat{$dst}{Y_min}+$$Cat{$dst}{Y_max})/2*$grid_Y_size] ]; $line->{'forwardarrow'} = ['1', '1', '1.00', '60.00', '120.00']; $fig->add ($line); } # Host visualization my($max_Y)= 0; my($index_fill)=0; my($width_of_one_letter)=80; my($min_x_for_host)=-400 - $max_string_length*$width_of_one_letter; my($host_text_x)= $min_x_for_host + 200; foreach $cat (keys %$Cat) { next unless (defined($$Cat{$cat}{Y_min_host}) && defined($$Cat{$cat}{Y_max_host})); my($line) = new XFig ('polyline'); $line->{'depth'} = 150; $line->{'subtype'} = 1; # line $line->{'points'} = [ [$min_x_for_host, $$Cat{$cat}{Y_min_host}*$grid_Y_size], [$max_date*$grid_X_size+150, $$Cat{$cat}{Y_min_host}*$grid_Y_size], [$max_date*$grid_X_size+150, $$Cat{$cat}{Y_max_host}*$grid_Y_size], [$min_x_for_host, $$Cat{$cat}{Y_max_host}*$grid_Y_size] ]; $line->{'areafill'} = 4+3*($index_fill % 2); $line->{'fillcolor'} = 0; $line->{'thickness'} = 0; $index_fill++; $fig->add ($line); my($text) = new XFig ('text'); $text->{'text'} = "$$Cat{$cat}{name}"; $text->{'angle'} = 3.14159265/2; $text->{'x'} = $host_text_x; $text->{'y'} = ($$Cat{$cat}{Y_min_host}+$$Cat{$cat}{Y_max_host})/2*$grid_Y_size; $text->{'subtype'} = 1; $text->{'font_size'} = 30; $fig->add ($text); if ($max_Y<$$Cat{$cat}{Y_max_host}) { $max_Y = $$Cat{$cat}{Y_max_host}; } } # Legend: my($i)=1; my($color); foreach $color (@color_list) { my($min_x)=0; my($min_Y)=($max_Y+1)*$grid_Y_size; my($width)=1700; my($height)=$grid_Y_size; my($line) = new XFig ('polyline'); $line->{'depth'} = 50; $line->{'subtype'} = 1; # line $line->{'points'} = [ [$min_x,$min_Y + ($i-1)*$height ], [$min_x + $width,$min_Y + ($i-1)*$height], [$min_x + $width,$min_Y+$height + ($i-1)*$height], [$min_x,$min_Y+$height + ($i-1)*$height], [$min_x,$min_Y+ ($i-1)*$height]]; $line->{'areafill'} = 20; $line->{'fillcolor'} = $color; $fig->add ($line); my($text) = new XFig ('text'); if ($color==$color_suspended) { $text->{'text'} = "Suspended"; } if ($color==$color_compute) { $text->{'text'} = "Computing"; } if ($color==$color_wait_for_recpt) { $text->{'text'} = "Waiting for reception"; } if ($color==$color_communicate) { $text->{'text'} = "Communicating"; } $text->{'y'} = $min_Y + ($i-0.5)*$height +68; $text->{'x'} = 50; $text->{'subtype'} = 0; $fig->add ($text); $i++; } # Time axis my($line) = new XFig ('polyline'); $line->{'depth'} = 0; $line->{'subtype'} = 1; # line $line->{'points'} = [ [0,0],[$max_date * $grid_X_size+150,0] ]; $line->{'forwardarrow'} = ['1', '1', '1.00', '60.00', '120.00']; $fig->add ($line); my($digits)=POSIX::floor(log($max_date)/log(10)); my($exponent) = 10**$digits; my($mantissa)= $max_date / $exponent; my($incr); if ($mantissa<2) { $incr = $exponent/10; } elsif ($mantissa<5) { $incr = $exponent/4; } else { $incr = $exponent/2; } print "$max_date $digits $exponent $mantissa $incr\n"; my($x); for($x=0; $x < $max_date; $x += $incr) { print "$x\n"; $line = new XFig ('polyline'); $line->{'depth'} = 0; $line->{'subtype'} = 1; # line $line->{'points'} = [ [$x * $grid_X_size,0],[$x * $grid_X_size, -100] ]; $line->{'forwardarrow'} = 0; $fig->add ($line); my($text) = new XFig ('text'); $text->{'text'} = "$x"; $text->{'y'} = -200; $text->{'x'} = $x * $grid_X_size; $text->{'subtype'} = 1; $fig->add ($text); } # Empty line so that the text of the time axis can be seen on the pdf $line = new XFig ('polyline'); $line->{'depth'} = 999; $line->{'subtype'} = 1; # line $line->{'thickness'} = 0; $line->{'points'} = [ [0,0],[0, -400] ]; $fig->add ($line); } sub main { my($Cat) = read_cat($ARGV[0]); my($cat_tree)=build_cat_tree("0",$Cat); read_event($ARGV[0],$Cat); my($Link)=read_link($ARGV[0]); # print Dumper($cat_tree); # print Dumper($Cat); my($cat_list)=[]; build_cat_list($cat_tree,$cat_list); shift @$cat_list; shift @$cat_list; # print "@$cat_list \n"; set_cat_position($Cat,$cat_list); my($fig)=create_fig("toto.fig"); draw_cat($fig,$Cat,$Link); $fig->writefile (); system "fig2dev -L pdf toto.fig toto.pdf"; } main; SimGrid-3.11/tools/simgrid_update_xml.pl000755 001750 001750 00000011627 12342443657 017425 0ustar00cici000000 000000 #! /usr/bin/env perl eval 'exec perl -S $0 ${1+"$@"}' if $running_under_some_shell; # This script updates the simgrid XML file passed as argument (modification in place) # It is built to do the conversion incrementally. # Copyright (c) 2006-2014. The SimGrid Team. # All rights reserved. # # This program is free software; you can redistribute it and/or modify it # under the terms of the license (GNU LGPL) which comes with this package. =encoding UTF-8 =head1 NAME simgrid_update_xml - updates simgrid XML files to latest version =head1 SYNOPSIS B I =head1 DESCRIPTION simgrid_update_xml updates the simgrid XML file passed as argument. The file is modified in place, without any kind of backup. You may want to save a copy before running the script. In SimGrid XML files, the standard version is indicated in the version attribute of the platform tag. Current version is 3. Here is a list of major changes in each version. =over 4 =item B Used before SimGrid 3.3 =item B Introduced in SimGrid 3.3 =over 4 =item The version attribute of platform were added to allow file versionning. =item The link bandwidth changed from Mb/s to b/s; and the CPU power were changed from MFlop/s to Flop/s =back =item B Introduced in SimGrid 3.4 =over =item Several tags were renamed: CPU -> HOST NETWORK_LINK -> LINK ROUTE_ELEMENT -> LINK_CTN PLATFORM_DESCRIPTION -> PLATFORM =back =item B Introduced in SimGrid 3.5 (this is the current version) =over 4 =item The AS tag were introduced. Every plaform should now contain an englobing AS tag. =item Routes are now symmetric by default. =item Several tags were renamed (for sake of XML sanity): LINK:CTN -> LINK_CTN TRACE:CONNECT -> TRACE_CONNECT =back =back =head1 AUTHORS The SimGrid team (simgrid-devel@lists.gforge.inria.fr) =head1 COPYRIGHT AND LICENSE Copyright (c) 2006-2014. The SimGrid Team. All rights reserved. This program is free software; you may redistribute it and/or modify it under the terms of GNU LGPL (v2.1) license. =cut use strict; my $fromversion=-1; my $toversion=3; my($output_string); $ARGV[0] or die "simgrid_update_xml.pl \n"; open INPUT, "$ARGV[0]" or die "Cannot open input file $ARGV[0]: $!\n"; $output_string = "\n". "\n". "\n"; my($AS_opened)=0; my $line; while (defined($line = )) { chomp $line; # eat the header, whatever form it has next if ($line =~ s/<\?xml[^>]*>// && ! $line =~ /\S/); # just in case several tags are on the same line next if ($line =~ s/]*>// && ! $line =~ /\S/); if ($line =~ s///) { $fromversion = 0; print "version 0\n"; next if !$line =~ /\S/; } elsif ($line =~ s///) { $fromversion = $1; print "version $fromversion\n"; if ($fromversion == $toversion) { die "Input platform file version is already $fromversion. This should be a no-op.\n"; } if ($fromversion > $toversion) { die "Input platform file version is more recent than this script (file version: $fromversion; script version: $toversion)\n"; } next if !$line =~ /\S/; } if ($fromversion == 0) { while ($line =~ m|^(.*?)/) || ($line=~ /\n"; $AS_opened=1; } } if($line=~/ $ARGV[0]"; print OUTPUT $output_string; close OUTPUT; SimGrid-3.11/tools/tesh/000755 001750 001750 00000000000 12342443666 014141 5ustar00cici000000 000000 SimGrid-3.11/tools/tesh/IO-orders.tesh000644 001750 001750 00000002365 12342443665 016636 0ustar00cici000000 000000 p This tests that TESH accepts any order for the input/output p Order: in, out, cmd < < TOTO < > TOTO < $ cat > Enable coverage > Test suite from stdin > [(stdin):3] cat > Test suite from stdin OK $ ./tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' p Order: out, in, cmd < > TOTO < < TOTO < $ cat > Enable coverage > Test suite from stdin > [(stdin):3] cat > Test suite from stdin OK $ ./tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' p Order: out, cmd, in < > TOTO < $ cat < < TOTO > Enable coverage > Test suite from stdin > [(stdin):2] cat > Test suite from stdin OK $ ./tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' p Order: in, cmd, out < < TOTO < $ cat < > TOTO > Enable coverage > Test suite from stdin > [(stdin):2] cat > Test suite from stdin OK $ ./tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' p Order: cmd, out, in < $ cat < > TOTO < < TOTO > Enable coverage > Test suite from stdin > [(stdin):1] cat > Test suite from stdin OK $ ./tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' p Order: cmd, in, out < $ cat < < TOTO < > TOTO > Enable coverage > Test suite from stdin > [(stdin):1] cat > Test suite from stdin OK $ ./tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' SimGrid-3.11/tools/tesh/catch-signal.tesh000644 001750 001750 00000001263 12342443665 017364 0ustar00cici000000 000000 #! ./tesh # This suite builds and uses a program raising a segfault, ie a program dying # of SIGSEV. tesh must detect this condition and report the issue. $ rm -rf temp_testdir-catch-signal $ mkdir temp_testdir-catch-signal $ cd temp_testdir-catch-signal < #include < int main(void) { < char *A=NULL; < *A = 1; < } $ mkfile segfault.c $ cc -o segfault segfault.c ! expect return 15 < $ ./segfault $ ../tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' > Enable coverage > Test suite from stdin > [(stdin):1] ./segfault > Test suite `(stdin)': NOK (<(stdin):1> got signal SIGSEGV) > Output of <(stdin):1> so far: > || $ cd .. $ rm -rf temp_testdir-catch-signal SimGrid-3.11/tools/tesh/run_context.c000644 001750 001750 00000066163 12342443666 016671 0ustar00cici000000 000000 /* run_context -- stuff in which TESH runs a command */ /* Copyright (c) 2007-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "tesh.h" #include #include #include #include #include #include /* floor */ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(tesh); int fg_job = 0; xbt_dynar_t bg_jobs = NULL; rctx_t armageddon_initiator = NULL; xbt_os_mutex_t armageddon_mutex = NULL; struct { int num; struct sigaction act; } oldact[3]; /* SIGINT, SIGQUIT, SIGTERM */ xbt_os_thread_t sigwaiter_thread; xbt_os_mutex_t sigwaiter_mutex; xbt_os_cond_t sigwaiter_cond; int armageddon_requested = 0; int caught_signum = 0; /* * Module management */ static void armageddon_sighandler(int signum) { xbt_os_mutex_acquire(sigwaiter_mutex); caught_signum = signum; armageddon_requested = 1; xbt_os_cond_signal(sigwaiter_cond); xbt_os_mutex_release(sigwaiter_mutex); } static void *armageddon_sigwaiter(_XBT_GNUC_UNUSED void *arg) { xbt_os_mutex_acquire(sigwaiter_mutex); /* Inform main thread that it started. */ xbt_os_cond_signal(sigwaiter_cond); /* Wait for ending signal... */ xbt_os_cond_wait(sigwaiter_cond, sigwaiter_mutex); if (armageddon_requested) { XBT_ERROR("Test suite `%s': caught signal %d", testsuite_name, caught_signum); rctx_armageddon(rctx, 3); } xbt_os_mutex_release(sigwaiter_mutex); return NULL; } static void wait_it(rctx_t rctx) { XBT_VERB("Join thread %p which were running background cmd <%s>", rctx->runner, rctx->filepos); xbt_os_thread_join(rctx->runner, NULL); } static void kill_it(void *r) { rctx_t rctx = *(rctx_t *) r; wait_it(rctx); rctx_free(rctx); } void rctx_init(void) { struct sigaction newact; int i; fg_job = 0; bg_jobs = xbt_dynar_new(sizeof(rctx_t), kill_it); armageddon_mutex = xbt_os_mutex_init(); armageddon_initiator = NULL; sigwaiter_mutex = xbt_os_mutex_init(); sigwaiter_cond = xbt_os_cond_init(); xbt_os_mutex_acquire(sigwaiter_mutex); sigwaiter_thread = xbt_os_thread_create("Armageddon request waiter", armageddon_sigwaiter, NULL, NULL); /* Wait for thread to start... */ xbt_os_cond_wait(sigwaiter_cond, sigwaiter_mutex); xbt_os_mutex_release(sigwaiter_mutex); memset(&newact, 0, sizeof(newact)); newact.sa_handler = armageddon_sighandler; oldact[0].num = SIGINT; oldact[1].num = SIGQUIT; oldact[2].num = SIGTERM; for (i = 0; i < 3; i++) sigaction(oldact[i].num, &newact, &oldact[i].act); } void rctx_exit(void) { int i; for (i = 0; i < 3; i++) sigaction(oldact[i].num, &oldact[i].act, NULL); xbt_os_cond_signal(sigwaiter_cond); xbt_os_thread_join(sigwaiter_thread, NULL); xbt_dynar_free(&bg_jobs); xbt_os_cond_destroy(sigwaiter_cond); xbt_os_mutex_destroy(sigwaiter_mutex); xbt_os_mutex_destroy(armageddon_mutex); } void rctx_wait_bg(void) { /* Do not use xbt_dynar_free or it will lock the dynar, preventing armageddon * from working */ while (!xbt_dynar_is_empty(bg_jobs)) { rctx_t rctx = xbt_dynar_getlast_as(bg_jobs, rctx_t); wait_it(rctx); xbt_dynar_pop(bg_jobs, &rctx); rctx_free(rctx); } xbt_dynar_reset(bg_jobs); } static void rctx_armageddon_kill_one(rctx_t initiator, const char *filepos, rctx_t rctx) { if (rctx != initiator) { XBT_INFO("Kill <%s> because <%s> failed", rctx->filepos, filepos); xbt_os_mutex_acquire(rctx->interruption); if (!rctx->reader_done) { rctx->interrupted = 1; kill(rctx->pid, SIGTERM); struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = (100e-6 - floor(100e-6)) * 1e9; nanosleep (&ts, NULL); kill(rctx->pid, SIGKILL); } xbt_os_mutex_release(rctx->interruption); } } void rctx_armageddon(rctx_t initiator, int exitcode) { unsigned int cursor; rctx_t job; const char *filepos = initiator && initiator->filepos ? initiator->filepos : "(master)"; XBT_DEBUG("Armageddon request by <%s> (exit=%d)", filepos, exitcode); xbt_os_mutex_acquire(armageddon_mutex); if (armageddon_initiator != NULL) { XBT_VERB("Armageddon already started. Let it go"); xbt_os_mutex_release(armageddon_mutex); return; } XBT_DEBUG("Armageddon request by <%s> got the lock. Let's go amok", filepos); armageddon_initiator = initiator; xbt_os_mutex_release(armageddon_mutex); /* Kill foreground command */ if (fg_job) rctx_armageddon_kill_one(initiator, filepos, rctx); /* Kill any background commands */ xbt_dynar_foreach(bg_jobs, cursor, job) { rctx_armageddon_kill_one(initiator, filepos, job); } /* Give runner threads a chance to acknowledge the processes deaths */ struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = (10000e-6 - floor(10000e-6)) * 1e9; nanosleep (&ts, NULL); /* Ensure that nobody is running rctx_wait on exit */ if (fg_job) xbt_os_mutex_acquire(rctx->interruption); xbt_dynar_foreach(bg_jobs, cursor, job) xbt_os_mutex_acquire(job->interruption); XBT_VERB("Shut everything down!"); exit(exitcode); } /* * Memory management */ void rctx_empty(rctx_t rc) { int i; char **env_it; void *filepos; free(rc->cmd); rc->cmd = NULL; /* avoid race with rctx_armageddon log messages */ filepos = rc->filepos; rc->filepos = NULL; free(filepos); for (i = 0, env_it = environ; *env_it; i++, env_it++); if (rc->env) { for (env_it = rctx->env + i; *env_it; env_it++) free(*env_it); free(rc->env); } rc->env_size = i + 1; rc->env = malloc(rc->env_size * sizeof(char *)); memcpy(rc->env, environ, rc->env_size * sizeof(char *)); rc->is_empty = 1; rc->is_background = 0; rc->is_stoppable = 0; rc->output = e_output_check; rc->output_sort = 0; rc->brokenpipe = 0; rc->timeout = 0; rc->interrupted = 0; xbt_strbuff_empty(rc->input); xbt_strbuff_empty(rc->output_wanted); xbt_strbuff_empty(rc->output_got); } rctx_t rctx_new() { rctx_t res = xbt_new0(s_rctx_t, 1); res->input = xbt_strbuff_new(); res->output_sort = 0; res->output_wanted = xbt_strbuff_new(); res->output_got = xbt_strbuff_new(); res->interruption = xbt_os_mutex_init(); rctx_empty(res); return res; } void rctx_free(rctx_t rctx) { XBT_DEBUG("RCTX: Free %p", rctx); rctx_dump(rctx, "free"); if (!rctx) return; free(rctx->cmd); free(rctx->filepos); if (rctx->env) { int i; char **env_it; for (i = 0, env_it = environ; *env_it; i++, env_it++); for (env_it = rctx->env + i; *env_it; env_it++) free(*env_it); free(rctx->env); } xbt_os_mutex_destroy(rctx->interruption); xbt_strbuff_free(rctx->input); xbt_strbuff_free(rctx->output_got); xbt_strbuff_free(rctx->output_wanted); free(rctx); } void rctx_dump(rctx_t rctx, const char *str) { XBT_DEBUG("%s RCTX %p={in%p={%d,%10s}, want={%d,%10s}, out={%d,%10s}}", str, rctx, rctx->input, rctx->input->used, rctx->input->data, rctx->output_wanted->used, rctx->output_wanted->data, rctx->output_got->used, rctx->output_got->data); XBT_DEBUG("%s RCTX %p=[cmd%p=%10s, pid=%d]", str, rctx, rctx->cmd, rctx->cmd, rctx->pid); } /* * Getting instructions from the file */ void rctx_pushline(const char *filepos, char kind, char *line) { switch (kind) { case '$': case '&': if (rctx->cmd) { if (!rctx->is_empty) { XBT_ERROR ("[%s] More than one command in this chunk of lines (previous: %s).\n" " Cannot guess which input/output belongs to which command.", filepos, rctx->cmd); XBT_ERROR("Test suite `%s': NOK (syntax error)", testsuite_name); rctx_armageddon(rctx, 1); return; } rctx_start(); XBT_VERB("[%s] More than one command in this chunk of lines", filepos); } if (kind == '&') rctx->is_background = 1; else rctx->is_background = 0; rctx->cmd = xbt_strdup(line); rctx->filepos = xbt_strdup(filepos); if (option){ char *newcmd = bprintf("%s %s", rctx->cmd, option); free(rctx->cmd); rctx->cmd = newcmd; } XBT_INFO("[%s] %s%s", filepos, rctx->cmd, ((rctx->is_background) ? " (background command)" : "")); break; case '<': rctx->is_empty = 0; xbt_strbuff_append(rctx->input, line); xbt_strbuff_append(rctx->input, "\n"); break; case '>': rctx->is_empty = 0; xbt_strbuff_append(rctx->output_wanted, line); xbt_strbuff_append(rctx->output_wanted, "\n"); XBT_DEBUG("wanted:%s",rctx->output_wanted->data); break; case '!': if (rctx->cmd) rctx_start(); if (!strncmp(line, "timeout no", strlen("timeout no"))) { XBT_VERB("[%s] (disable timeout)", filepos); timeout_value = -1; } else if (!strncmp(line, "timeout ", strlen("timeout "))) { timeout_value = atoi(line + strlen("timeout")); XBT_VERB("[%s] (new timeout value: %d)", filepos, timeout_value); } else if (!strncmp(line, "expect signal ", strlen("expect signal "))) { rctx->expected_signal = strdup(line + strlen("expect signal ")); xbt_str_trim(rctx->expected_signal, " \n"); XBT_VERB("[%s] (next command must raise signal %s)", filepos, rctx->expected_signal); } else if (!strncmp(line, "expect return ", strlen("expect return "))) { rctx->expected_return = atoi(line + strlen("expect return ")); XBT_VERB("[%s] (next command must return code %d)", filepos, rctx->expected_return); } else if (!strncmp(line, "output sort", strlen("output sort"))) { sort_len = atoi(line + strlen("output sort")); if (sort_len==0) sort_len=SORT_LEN_DEFAULT; rctx->output_sort = 1; XBT_VERB("[%s] (sort output of next command)", filepos); } else if (!strncmp(line, "output ignore", strlen("output ignore"))) { rctx->output = e_output_ignore; XBT_VERB("[%s] (ignore output of next command)", filepos); } else if (!strncmp(line, "output display", strlen("output display"))) { rctx->output = e_output_display; XBT_VERB("[%s] (ignore output of next command)", filepos); } else if (!strncmp(line, "setenv ", strlen("setenv "))) { int len = strlen("setenv "); char *eq = strchr(line + len, '='); char *key = bprintf("%.*s", (int) (eq - line - len), line + len); xbt_dict_set(env, key, xbt_strdup(eq + 1), NULL); free(key); rctx->env = realloc(rctx->env, ++(rctx->env_size) * sizeof(char *)); rctx->env[rctx->env_size - 2] = xbt_strdup(line + len); rctx->env[rctx->env_size - 1] = NULL; XBT_VERB("[%s] setenv %s", filepos, line + len); } else { XBT_ERROR("%s: Malformed metacommand: %s", filepos, line); XBT_ERROR("Test suite `%s': NOK (syntax error)", testsuite_name); rctx_armageddon(rctx, 1); return; } break; } } /* * Actually doing the job */ /* The IO of the childs are handled by the two following threads (one pair per child) */ static void *thread_writer(void *r) { int posw; rctx_t rctx = (rctx_t) r; for (posw = 0; posw < rctx->input->used && !rctx->brokenpipe;) { int got; XBT_DEBUG("Still %d chars to write", rctx->input->used - posw); got = write(rctx->child_to, rctx->input->data + posw, rctx->input->used - posw); if (got > 0) posw += got; if (got < 0) { if (errno == EPIPE) { rctx->brokenpipe = 1; } else if (errno != EINTR && errno != EAGAIN && errno != EPIPE) { perror("Error while writing input to child"); XBT_ERROR("Test suite `%s': NOK (system error)", testsuite_name); rctx_armageddon(rctx, 4); return NULL; } } XBT_DEBUG("written %d chars so far", posw); if (got <= 0){ struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = (100e-6 - floor(100e-6)) * 1e9; nanosleep (&ts, NULL); } } rctx->input->data[0] = '\0'; rctx->input->used = 0; close(rctx->child_to); return NULL; } static void *thread_reader(void *r) { rctx_t rctx = (rctx_t) r; char *buffout = malloc(4096); int posr, got_pid; do { posr = read(rctx->child_from, buffout, 4095); if (posr < 0 && errno != EINTR && errno != EAGAIN) { perror("Error while reading output of child"); XBT_ERROR("Test suite `%s': NOK (system error)", testsuite_name); rctx_armageddon(rctx, 4); return NULL; } if (posr > 0) { buffout[posr] = '\0'; xbt_strbuff_append(rctx->output_got, buffout); } else { struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = (100e-6 - floor(100e-6)) * 1e9; nanosleep (&ts, NULL); } } while (!rctx->timeout && posr != 0); free(buffout); /* let this thread wait for the child so that the main thread can detect the timeout without blocking on the wait */ got_pid = waitpid(rctx->pid, &rctx->status, 0); if (got_pid != rctx->pid) { perror(bprintf ("(%s) Cannot wait for the child %s (got pid %d where pid %d were expected;status=%d)", xbt_thread_self_name(), rctx->cmd, (int) got_pid, (int) rctx->pid, rctx->status)); XBT_ERROR("Test suite `%s': NOK (system error)", testsuite_name); rctx_armageddon(rctx, 4); return NULL; } rctx->reader_done = 1; return NULL; } /* Special command: mkfile is a built-in creating a file with the input data as content */ static void rctx_mkfile(void) { char *filename = xbt_strdup(rctx->cmd + strlen("mkfile ")); FILE *OUT; int err; xbt_str_trim(filename, NULL); OUT = fopen(filename, "w"); if (!OUT) { THROWF(system_error, errno, "%s: Cannot create file %s: %s", rctx->filepos, filename, strerror(errno)); } err = (fprintf(OUT, "%s", rctx->input->data) < 0); err = (fclose(OUT) == -1) || err; if (err) { THROWF(system_error, errno, "%s: Cannot write file %s: %s", rctx->filepos, filename, strerror(errno)); } free(filename); } /* function to be called from the child to start the actual process */ static void start_command(rctx_t rctx) { xbt_dynar_t cmd; char *binary_name = NULL; unsigned int it; char *str; char **args; int errcode; if (!strncmp(rctx->cmd, "mkfile ", strlen("mkfile "))) { rctx_mkfile(); /* Valgrind detects memory leaks here. * To correct those leaks, we must free objects allocated in main() or in * handle_suite(), but we have no more reference to them at this point. * A quick and dirty hack to make valgrind happy it to uncomment the * following line. */ /* execlp("true", "true", (const char *)0); */ exit(0); /* end the working child */ } cmd = xbt_str_split_quoted(rctx->cmd); xbt_dynar_get_cpy(cmd, 0, &binary_name); args = xbt_new(char *, xbt_dynar_length(cmd) + 1); xbt_dynar_foreach(cmd, it, str) { args[it] = xbt_strdup(str); } args[it] = NULL; xbt_dynar_free_container(&cmd); /* To search for the right executable path when not trivial */ struct stat stat_buf; /* build the command line */ if (stat(binary_name, &stat_buf)) { /* Damn. binary not in current dir. We'll have to dig the PATH to find it */ int i; for (i = 0; environ[i]; i++) { if (!strncmp("PATH=", environ[i], 5)) { xbt_dynar_t path = xbt_str_split(environ[i] + 5, ":"); xbt_dynar_foreach(path, it, str) { free(binary_name); binary_name = bprintf("%s/%s", str, args[0]); if (!stat(binary_name, &stat_buf)) { /* Found. */ XBT_DEBUG("Looked in the PATH for the binary. Found %s", binary_name); xbt_dynar_free(&path); break; } } xbt_dynar_free(&path); if (stat(binary_name, &stat_buf)) { /* not found */ printf("TESH_ERROR Command %s not found\n", args[0]); exit(127); } break; } } } else { binary_name = xbt_strdup(args[0]); } errcode = execve(binary_name, args, rctx->env); printf("TESH_ERROR %s: Cannot start %s: %s\n", rctx->filepos, rctx->cmd, strerror(errcode)); exit(127); } /* Start a new child, plug the pipes as expected and fire up the helping threads. Is also waits for the child to end if this is a foreground job, or fire up a thread to wait otherwise. */ void rctx_start(void) { int child_in[2]; int child_out[2]; XBT_DEBUG("Cmd before rewriting %s", rctx->cmd); char *newcmd = xbt_str_varsubst(rctx->cmd, env); free(rctx->cmd); rctx->cmd = newcmd; XBT_VERB("Start %s %s", rctx->cmd, (rctx->is_background ? "(background job)" : "")); xbt_os_mutex_acquire(armageddon_mutex); if (armageddon_initiator) { XBT_VERB("Armageddon in progress. Do not start job."); xbt_os_mutex_release(armageddon_mutex); return; } if (pipe(child_in) || pipe(child_out)) { perror("Cannot open the pipes"); XBT_ERROR("Test suite `%s': NOK (system error)", testsuite_name); xbt_os_mutex_release(armageddon_mutex); rctx_armageddon(rctx, 4); } rctx->pid = fork(); if (rctx->pid < 0) { perror("Cannot fork the command"); XBT_ERROR("Test suite `%s': NOK (system error)", testsuite_name); xbt_os_mutex_release(armageddon_mutex); rctx_armageddon(rctx, 4); return; } if (rctx->pid) { /* father */ close(child_in[0]); rctx->child_to = child_in[1]; close(child_out[1]); rctx->child_from = child_out[0]; if (timeout_value > 0) rctx->end_time = time(NULL) + timeout_value; else rctx->end_time = -1; rctx->reader_done = 0; rctx->reader = xbt_os_thread_create("reader", thread_reader, (void *) rctx, NULL); rctx->writer = xbt_os_thread_create("writer", thread_writer, (void *) rctx, NULL); } else { /* child */ close(child_in[1]); dup2(child_in[0], 0); close(child_in[0]); close(child_out[0]); dup2(child_out[1], 1); dup2(child_out[1], 2); close(child_out[1]); start_command(rctx); } rctx->is_stoppable = 1; if (!rctx->is_background) { fg_job = 1; xbt_os_mutex_release(armageddon_mutex); rctx_wait(rctx); fg_job = 0; } else { /* Damn. Copy the rctx and launch a thread to handle it */ rctx_t old = rctx; xbt_os_thread_t runner; rctx = rctx_new(); XBT_DEBUG("RCTX: new bg=%p, new fg=%p", old, rctx); XBT_DEBUG("Launch a thread to wait for %s %d", old->cmd, old->pid); runner = xbt_os_thread_create(old->cmd, rctx_wait, (void *) old, NULL); old->runner = runner; XBT_VERB("Launched thread %p to wait for %s %d", runner, old->cmd, old->pid); xbt_dynar_push(bg_jobs, &old); xbt_os_mutex_release(armageddon_mutex); } } /* Helper function to sort the output */ static int cmpstringp(const void *p1, const void *p2) { /* Sort only using the sort_len first chars * If they are the same, then, sort using pointer address * (be stable wrt output of each process) */ const char **s1 = *(const char***)p1; const char **s2 = *(const char***)p2; XBT_DEBUG("Compare strings '%s' and '%s'", *s1, *s2); int res = strncmp(*s1, *s2, sort_len); if (res == 0) res = s1 > s2 ? 1 : (s1 < s2 ? -1 : 0); return res; } static void stable_sort(xbt_dynar_t a) { unsigned long len = xbt_dynar_length(a); void **b = xbt_new(void*, len); unsigned long i; for (i = 0 ; i < len ; i++) /* fill the array b with pointers to strings */ b[i] = xbt_dynar_get_ptr(a, i); qsort(b, len, sizeof *b, cmpstringp); /* sort it */ for (i = 0 ; i < len ; i++) /* dereference the pointers to get the strings */ b[i] = *(char**)b[i]; for (i = 0 ; i < len ; i++) /* put everything in place */ xbt_dynar_set_as(a, i, char*, b[i]); xbt_free(b); } /* Waits for the child to end (or to timeout), and check its ending conditions. This is launched from rctx_start but either in main thread (for foreground jobs) or in a separate one for background jobs. That explains the prototype, forced by xbt_os_thread_create. */ void *rctx_wait(void *r) { rctx_t rctx = (rctx_t) r; int errcode = 0; int now = time(NULL); rctx_dump(rctx, "wait"); if (!rctx->is_stoppable) THROWF(unknown_error, 0, "Cmd '%s' not started yet. Cannot wait it", rctx->cmd); /* Wait for the child to die or the timeout to happen (or an armageddon to happen) */ while (!rctx->reader_done && (rctx->end_time < 0 || rctx->end_time >= now)) { struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = (100e-6 - floor(100e-6)) * 1e9; nanosleep (&ts, NULL); now = time(NULL); } xbt_os_mutex_acquire(rctx->interruption); if (!rctx->interrupted && rctx->end_time > 0 && rctx->end_time < now) { XBT_INFO("<%s> timeouted. Kill the process.", rctx->filepos); rctx->timeout = 1; kill(rctx->pid, SIGTERM); struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = (100e-6 - floor(100e-6)) * 1e9; nanosleep (&ts, NULL); kill(rctx->pid, SIGKILL); } /* Make sure helper threads die. Cannot block since they wait for the child we just killed if not already dead. */ xbt_os_thread_join(rctx->writer, NULL); xbt_os_thread_join(rctx->reader, NULL); /* xbt_os_mutex_release(rctx->interruption); if (rctx->interrupted) return NULL; xbt_os_mutex_acquire(rctx->interruption); */ { // Sorting output got xbt_dynar_t a = xbt_str_split(rctx->output_got->data, "\n"); xbt_dynar_t b = xbt_dynar_new(sizeof(char *), NULL); unsigned cpt; char *str; xbt_dynar_foreach(a, cpt, str) { if (strncmp(str, "TESH_ERROR ", (sizeof "TESH_ERROR ") - 1) == 0) { XBT_CRITICAL("%s", str); errcode = 1; } else if (coverage && strncmp(str, "profiling:", (sizeof "profiling:") - 1) == 0) { XBT_DEBUG("Remove line [%u]: '%s'", cpt, str); } else { xbt_dynar_push_as(b, char *, str); } } if (rctx->output_sort) { stable_sort(b); /* If empty lines moved in first position, remove them */ while (!xbt_dynar_is_empty(b) && *xbt_dynar_getfirst_as(b, char*) == '\0') xbt_dynar_shift(b, NULL); } if (rctx->output_sort || xbt_dynar_length(b) != xbt_dynar_length(a)) { char *newbuf = xbt_str_join(b, "\n"); strcpy(rctx->output_got->data, newbuf); rctx->output_got->used = strlen(newbuf); xbt_free(newbuf); } xbt_dynar_free(&b); xbt_dynar_free(&a); } if (rctx->output_sort) { // Sorting output wanted char *newbuf; xbt_dynar_t a = xbt_str_split(rctx->output_wanted->data, "\n"); stable_sort(a); /* If empty lines moved in first position, remove them */ while (!xbt_dynar_is_empty(a) && *xbt_dynar_getfirst_as(a, char*) == '\0') xbt_dynar_shift(a, NULL); newbuf = xbt_str_join(a, "\n"); strcpy(rctx->output_wanted->data, newbuf); rctx->output_wanted->used = strlen(newbuf); xbt_free(newbuf); xbt_dynar_free(&a); } xbt_strbuff_chomp(rctx->output_got); xbt_strbuff_chomp(rctx->output_wanted); /* Check for broken pipe */ if (rctx->brokenpipe) XBT_VERB ("Warning: Child did not consume all its input (I got broken pipe)"); /* Check for timeouts */ if (rctx->timeout) { if (rctx->output_got->data[0]) XBT_INFO("<%s> Output on timeout:\n%s", rctx->filepos, rctx->output_got->data); else XBT_INFO("<%s> No output before timeout", rctx->filepos); XBT_ERROR("Test suite `%s': NOK (<%s> timeout after %d sec)", testsuite_name, rctx->filepos, timeout_value); XBT_DEBUG("<%s> Interrupted = %d", rctx->filepos, (int)rctx->interrupted); if (!rctx->interrupted) { xbt_os_mutex_release(rctx->interruption); rctx_armageddon(rctx, 3); return NULL; } } XBT_DEBUG("RCTX=%p (pid=%d)", rctx, rctx->pid); XBT_DEBUG("Status(%s|%d)=%d", rctx->cmd, rctx->pid, rctx->status); if (!rctx->interrupted) { if (WIFSIGNALED(rctx->status) && !rctx->expected_signal) { XBT_ERROR("Test suite `%s': NOK (<%s> got signal %s)", testsuite_name, rctx->filepos, signal_name(WTERMSIG(rctx->status), NULL)); errcode = WTERMSIG(rctx->status) + 4; } if (WIFSIGNALED(rctx->status) && rctx->expected_signal && strcmp(signal_name(WTERMSIG(rctx->status), rctx->expected_signal), rctx->expected_signal)) { XBT_ERROR("Test suite `%s': NOK (%s got signal %s instead of %s)", testsuite_name, rctx->filepos, signal_name(WTERMSIG(rctx->status), rctx->expected_signal), rctx->expected_signal); errcode = WTERMSIG(rctx->status) + 4; } if (!WIFSIGNALED(rctx->status) && rctx->expected_signal) { XBT_ERROR("Test suite `%s': NOK (child %s expected signal %s)", testsuite_name, rctx->filepos, rctx->expected_signal); errcode = 5; } if (WIFEXITED(rctx->status) && WEXITSTATUS(rctx->status) != rctx->expected_return) { if (rctx->expected_return) XBT_ERROR ("Test suite `%s': NOK (<%s> returned code %d instead of %d)", testsuite_name, rctx->filepos, WEXITSTATUS(rctx->status), rctx->expected_return); else XBT_ERROR("Test suite `%s': NOK (<%s> returned code %d)", testsuite_name, rctx->filepos, WEXITSTATUS(rctx->status)); errcode = 40 + WEXITSTATUS(rctx->status); } rctx->expected_return = 0; free(rctx->expected_signal); rctx->expected_signal = NULL; } if ((errcode && errcode != 1) || rctx->interrupted) { /* checking output, and matching */ xbt_dynar_t a = xbt_str_split(rctx->output_got->data, "\n"); char *out = xbt_str_join(a, "\n||"); xbt_dynar_free(&a); XBT_INFO("Output of <%s> so far:\n||%s", rctx->filepos, out); free(out); } else if (rctx->output == e_output_check && (rctx->output_got->used != rctx->output_wanted->used || strcmp(rctx->output_got->data, rctx->output_wanted->data))) { if (XBT_LOG_ISENABLED(tesh, xbt_log_priority_info)) { char *diff = xbt_str_diff(rctx->output_wanted->data, rctx->output_got->data); XBT_ERROR("Output of <%s> mismatch:\n%s", rctx->filepos, diff); free(diff); } XBT_ERROR("Test suite `%s': NOK (<%s> output mismatch)", testsuite_name, rctx->filepos); errcode = 2; } else if (rctx->output == e_output_ignore) { XBT_INFO("(ignoring the output of <%s> as requested)", rctx->filepos); } else if (rctx->output == e_output_display) { xbt_dynar_t a = xbt_str_split(rctx->output_got->data, "\n"); char *out = xbt_str_join(a, "\n||"); xbt_dynar_free(&a); XBT_INFO("Here is the (ignored) command output:\n||%s", out); free(out); } if (!rctx->is_background) { xbt_os_mutex_acquire(armageddon_mutex); /* Don't touch rctx if armageddon is in progress. */ if (!armageddon_initiator) rctx_empty(rctx); xbt_os_mutex_release(armageddon_mutex); } if (errcode) { if (!rctx->interrupted) { xbt_os_mutex_release(rctx->interruption); rctx_armageddon(rctx, errcode); return NULL; } } xbt_os_mutex_release(rctx->interruption); return NULL; } SimGrid-3.11/tools/tesh/bg-set-signal.tesh000644 001750 001750 00000000733 12342443665 017464 0ustar00cici000000 000000 #! ./tesh # This suite builds and uses a program raising a segfault, ie a program dying # of SIGSEV. tesh must detect this condition and report the issue. $ rm -rf temp_testdir-bg-set-signal $ mkdir temp_testdir-bg-set-signal $ cd temp_testdir-bg-set-signal < #include < int main(void) { < char *A=NULL; < *A = 1; < } $ mkfile segfault.c $ cc -o segfault segfault.c ! expect signal SIGSEGV & ./segfault $ sleep 1 $ cd .. $ rm -rf temp_testdir-bg-set-signal SimGrid-3.11/tools/tesh/set-output-sort.tesh000644 001750 001750 00000004031 12342443665 020141 0ustar00cici000000 000000 #! ./tesh p This tests whether TESH correctly sorts command output $ ${bindir:=.}/tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' set-output-sort-1.tesh > Enable coverage > Test suite `set-output-sort-1' > [set-output-sort-1:1] Test sorting and filtering of output > [set-output-sort-1:3] true > [set-output-sort-1:6] true > [set-output-sort-1:8] printf 'profiling: foo\\n' > [set-output-sort-1:10] printf 'profiling: foo' > [set-output-sort-1:13] printf 'profiling: foo\\n' > [set-output-sort-1:16] printf 'profiling: foo' > [set-output-sort-1:18] printf 'a\\nb\\nc\\nd\\n' > [set-output-sort-1:24] printf 'a\\nb\\nc\\nd' > [set-output-sort-1:31] printf 'c\\nd\\nb\\na\\n' > [set-output-sort-1:38] printf 'c\\nd\\nb\\na' > [set-output-sort-1:44] printf 'a\\nprofiling: foo\\nprofiling: bar\\nb\\nc\\nd\\nprofiling: baz\\n' > [set-output-sort-1:50] printf 'a\\nprofiling: foo\\nprofiling: bar\\nb\\nc\\nd\\nprofiling: baz' > [set-output-sort-1:57] printf 'c\\nprofiling: foo\\nprofiling: bar\\nd\\nb\\na\\nprofiling: baz\\n' > [set-output-sort-1:64] printf 'c\\nprofiling: foo\\nprofiling: bar\\nd\\nb\\na\\nprofiling: baz' > Test suite `set-output-sort-1' OK p Check the default prefix length (19) for "output sort" ! output sort < 12345678901234567 B line < 12345678901234567 A line $ cat > 12345678901234567 A line > 12345678901234567 B line ! output sort < 123456789012345678 B line < 123456789012345678 A line $ cat > 123456789012345678 B line > 123456789012345678 A line ! expect return 2 ! output ignore < ! output sort < < 123456789012345678 B line < < 123456789012345678 A line < $ cat < > 123456789012345678 A line < > 123456789012345678 B line $ ${bindir:=.}/tesh --enable-coverage p Check user-defined prefix length for "output sort" ! output sort 5 < 000 B line < 000 A line $ cat > 000 A line > 000 B line ! output sort 4 < 000 B line < 000 A line $ cat > 000 B line > 000 A line ! expect return 2 ! output ignore < ! output sort 4 < < 000 B line < < 000 A line < $ cat < > 000 A line < > 000 B line $ ${bindir:=.}/tesh --enable-coverage SimGrid-3.11/tools/tesh/tesh.h000644 001750 001750 00000003153 12342443666 015257 0ustar00cici000000 000000 /* TESH (Test Shell) -- mini shell specialized in running test units */ /* Copyright (c) 2007-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef TESH_H #define TESH_H #include "portable.h" #include "xbt/xbt_os_thread.h" #include "xbt/strbuff.h" /*** What we need to know about signals ***/ /******************************************/ /* return the name of a signal, aliasing SIGBUS to SIGSEGV since segfault leads to any of them depending on the system */ const char *signal_name(int got, char *expected); #include "run_context.h" /*** Options ***/ extern int timeout_value; /* child timeout value */ extern int sort_len; /* length of the prefix to sort */ extern char* option; /* cfg for command line */ #define SORT_LEN_DEFAULT 19 extern int coverage; /* coverage */ extern rctx_t rctx; extern const char *testsuite_name; /* Environment related definitions */ # ifdef __APPLE__ /* under darwin, the environment gets added to the process at startup time. So, it's not defined at library link time, forcing us to extra tricks */ # include # define environ (*_NSGetEnviron()) # else /* the environment, as specified by the opengroup, used to initialize the process properties */ extern char **environ; # endif extern xbt_dict_t env; /* the environment, stored as a dict (for variable substitution) */ #endif /* TESH_H */ SimGrid-3.11/tools/tesh/tesh.c000644 001750 001750 00000020120 12342443666 015243 0ustar00cici000000 000000 /* TESH (Test Shell) -- mini shell specialized in running test units */ /* Copyright (c) 2007-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /* specific to Borland Compiler */ #ifdef __BORLANDDC__ #pragma hdrstop #endif #include "tesh.h" #include "xbt.h" XBT_LOG_NEW_DEFAULT_CATEGORY(tesh, "TEst SHell utility"); /*** Options ***/ int timeout_value = 5; /* child timeout value */ int sort_len = 19; /* length of the prefix to sort */ char *option; int coverage = 0; /* whether the code coverage is enabled */ rctx_t rctx; const char *testsuite_name; xbt_dict_t env; static void handle_line(const char *filepos, char *line) { /* Search end */ xbt_str_rtrim(line + 2, "\n"); /* XBT_DEBUG("rctx={%s,in={%d,>>%10s<<},exp={%d,>>%10s<<},got={%d,>>%10s<<}}", rctx->cmd, rctx->input->used, rctx->input->data, rctx->output_wanted->used,rctx->output_wanted->data, rctx->output_got->used, rctx->output_got->data); */ XBT_DEBUG("[%s] %s", filepos, line); switch (line[0]) { case '#': break; case '$': /* further trim useless chars which are significant for in/output */ xbt_str_rtrim(line + 2, " \t"); /* Deal with CD commands here, not in rctx */ if (!strncmp("cd ", line + 2, 3)) { char *dir = line + 4; if (rctx->cmd) rctx_start(); /* search beginning */ while (*(dir++) == ' '); dir--; XBT_VERB("Saw cd '%s'", dir); if (chdir(dir)) { XBT_ERROR("Chdir to %s failed: %s", dir, strerror(errno)); XBT_ERROR("Test suite `%s': NOK (system error)", testsuite_name); rctx_armageddon(rctx, 4); } break; } /* else, pushline */ case '&': case '<': case '>': case '!': rctx_pushline(filepos, line[0], line + 2 /* pass '$ ' stuff */ ); break; case 'p': XBT_INFO("[%s] %s", filepos, line + 2); break; case 'P': XBT_CRITICAL("[%s] %s", filepos, line + 2); break; default: XBT_ERROR("[%s] Syntax error: %s", filepos, line); XBT_ERROR("Test suite `%s': NOK (syntax error)", testsuite_name); rctx_armageddon(rctx, 1); break; } } static void handle_suite(const char *filename, FILE * IN) { size_t len; int blankline; int linelen; char *line = NULL; int line_num = 0; char file_pos[256]; int to_be_continued; int buffbegin = 0; xbt_strbuff_t buff = NULL; buff = xbt_strbuff_new(); rctx = rctx_new(); while (xbt_getline(&line, &len, IN) != -1) { line_num++; /* Count the line length while checking wheather it's blank */ blankline = 1; linelen = 0; while (line[linelen] != '\0') { if (line[linelen] != ' ' && line[linelen] != '\t' && line[linelen] != '\n') blankline = 0; linelen++; } if (blankline) { if (!rctx->cmd && !rctx->is_empty) { XBT_ERROR("[%d] Error: no command found in this chunk of lines.", buffbegin); XBT_ERROR("Test suite `%s': NOK (syntax error)", testsuite_name); rctx_armageddon(rctx, 1); } if (rctx->cmd) rctx_start(); continue; } /* Deal with \ at the end of the line, and call handle_line on result */ to_be_continued = 0; if (linelen > 1 && line[linelen - 2] == '\\') { if (linelen > 2 && line[linelen - 3] == '\\') { /* Damn. Escaped \ */ line[linelen - 2] = '\n'; line[linelen - 1] = '\0'; } else { to_be_continued = 1; line[linelen - 2] = '\0'; if (!buff->used) buffbegin = line_num; } } if (buff->used || to_be_continued) { xbt_strbuff_append(buff, line); if (!to_be_continued) { snprintf(file_pos, 256, "%s:%d", filename, buffbegin); handle_line(file_pos, buff->data); xbt_strbuff_empty(buff); } } else { snprintf(file_pos, 256, "%s:%d", filename, line_num); handle_line(file_pos, line); } } /* Check that last command of the file ran well */ if (rctx->cmd) rctx_start(); /* Wait all background commands */ rctx_free(rctx); /* Clear buffers */ free(line); xbt_strbuff_free(buff); } static void parse_environ() { char *p; int i; char *eq = NULL; char *key = NULL; env = xbt_dict_new_homogeneous(xbt_free_f); for (i = 0; environ[i]; i++) { p = environ[i]; eq = strchr(p, '='); key = bprintf("%.*s", (int) (eq - p), p); xbt_dict_set(env, key, xbt_strdup(eq + 1), NULL); free(key); } } int main(int argc, char *argv[]) { FILE *IN = NULL; int i; char *suitename = NULL; struct sigaction newact; XBT_LOG_CONNECT(tesh); xbt_init(&argc, argv); rctx_init(); parse_environ(); /* Ignore pipe issues. They will show up when we try to send data to dead buddies, but we will stop doing so when we're done with provided input */ memset(&newact, 0, sizeof(newact)); newact.sa_handler = SIG_IGN; sigaction(SIGPIPE, &newact, NULL); /* Get args */ for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "--cd")) { if (i == argc - 1) { XBT_ERROR("--cd argument requires an argument"); exit(1); } if (chdir(argv[i + 1])) { XBT_ERROR("Cannot change directory to %s: %s", argv[i + 1], strerror(errno)); exit(1); } XBT_INFO("Change directory to %s", argv[i + 1]); memmove(argv + i, argv + i + 2, (argc - i - 1) * sizeof(char *)); argc -= 2; i -= 2; } else if (!strcmp(argv[i], "--setenv" )) { if (i == argc - 1) { XBT_ERROR("--setenv argument requires an argument"); exit(1); } char *eq = strchr(argv[i+1], '='); xbt_assert(eq,"The argument of --setenv must contain a '=' (got %s instead)",argv[i+1]); char *key = bprintf("%.*s", (int) (eq - argv[i+1]), argv[i+1]); xbt_dict_set(env, key, xbt_strdup(eq + 1), NULL); XBT_INFO("setting environment variable '%s' to '%s'", key, eq+1); free(key); memmove(argv + i, argv + i + 2, (argc - i - 1) * sizeof(char *)); argc -= 2; i -= 2; } else if (!strcmp(argv[i], "--cfg" )) { if (i == argc - 1) { XBT_ERROR("--cfg argument requires an argument"); exit(1); } if (!option){ //if option is NULL option = bprintf("--cfg=%s",argv[i+1]); } else { char *newoption = bprintf("%s --cfg=%s", option, argv[i+1]); free(option); option = newoption; } XBT_INFO("Add option \'--cfg=%s\' to command line",argv[i+1]); memmove(argv + i, argv + i + 2, (argc - i - 1) * sizeof(char *)); argc -= 2; i -= 2; } else if (!strcmp(argv[i], "--enable-coverage" )){ coverage = 1; XBT_INFO("Enable coverage"); memmove(argv + i, argv + i + 1, (argc - i - 1) * sizeof(char *)); argc -= 1; i -= 1; } } /* Find the description file */ if (argc == 1) { XBT_INFO("Test suite from stdin"); testsuite_name = "(stdin)"; handle_suite(testsuite_name, stdin); rctx_wait_bg(); XBT_INFO("Test suite from stdin OK"); } else { for (i = 1; i < argc; i++) { suitename = xbt_strdup(argv[i]); if (!strncmp("./", suitename, 2)) memmove(suitename, suitename + 2, strlen(suitename + 2)); if (strlen(suitename) > 5 && !strcmp(".tesh", suitename + strlen(suitename) - 5)) suitename[strlen(suitename) - 5] = '\0'; XBT_INFO("Test suite `%s'", suitename); testsuite_name = suitename; IN = fopen(argv[i], "r"); if (!IN) { perror(bprintf("Impossible to open the suite file `%s'", argv[i])); XBT_ERROR("Test suite `%s': NOK (system error)", testsuite_name); rctx_armageddon(rctx, 1); } handle_suite(suitename, IN); rctx_wait_bg(); fclose(IN); XBT_INFO("Test suite `%s' OK", suitename); free(suitename); } } rctx_exit(); xbt_dict_free(&env); free(option); return 0; } SimGrid-3.11/tools/tesh/IO-bigsize.tesh000644 001750 001750 00001573236 12342443665 017007 0ustar00cici000000 000000 #! ./tesh # This suite contains two tests: # The first one uses a very big input (150k) to check whether trucated input do work. # The second one uses both a big input and a big output (150k each). # # This checks whether the non-blocking I/O mess is functionnal. # p First, a write test < 000 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 001 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 002 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 003 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 004 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 005 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 006 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 007 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 008 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 009 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 010 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 011 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 012 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 013 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 014 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 015 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 016 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 017 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 018 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 019 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 020 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 021 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 022 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 023 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 024 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 025 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 026 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 027 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 028 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 029 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 030 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 031 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 032 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 033 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 034 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 035 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 036 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 037 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 038 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 039 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 040 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 041 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 042 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 043 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 044 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 045 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 046 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 047 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 048 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 049 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 010 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 051 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 052 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 053 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 054 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 055 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 056 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 057 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 058 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 059 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 060 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 061 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 062 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 063 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 064 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 065 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 066 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 067 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 068 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 069 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 070 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 071 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 072 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 073 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 074 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 075 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 076 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 077 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 078 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 079 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 080 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 081 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 082 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 083 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 084 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 085 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 086 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 087 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 088 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 089 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 090 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 091 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 092 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 093 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 094 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 095 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 096 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 097 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 098 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 099 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 100 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 101 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 102 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 103 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 104 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 105 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 106 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 107 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 108 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 109 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 110 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 111 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 112 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 113 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 114 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 115 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 116 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 117 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 118 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 119 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 120 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 121 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 122 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 123 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 124 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 125 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 126 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 127 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 128 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 129 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 130 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 131 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 132 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 133 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 134 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 135 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 136 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 137 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 138 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 139 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 140 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 141 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 142 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 143 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 144 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 145 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 146 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 147 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 148 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 149 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 110 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 151 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 152 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 153 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 154 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 155 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 156 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 157 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 158 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 159 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 160 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 161 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 162 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 163 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 164 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 165 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 166 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 167 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 168 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 169 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 170 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 171 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 172 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 173 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 174 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 175 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 176 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 177 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 178 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 179 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 180 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 181 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 182 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 183 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 184 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 185 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 186 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 187 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 188 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 189 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 190 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 191 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 192 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 193 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 194 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 195 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 196 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 197 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 198 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 199 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 200 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 201 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 202 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 203 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 204 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 205 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 206 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 207 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 208 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 209 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 210 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 211 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 212 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 213 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 214 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 215 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 216 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 217 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 218 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 219 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 220 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 221 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 222 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 223 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 224 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 225 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 226 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 227 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 228 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 229 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 230 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 231 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 232 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 233 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 234 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 235 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 236 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 237 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 238 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 239 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 240 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 241 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 242 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 243 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 244 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 245 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 246 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 247 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 248 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 249 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 210 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 251 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 252 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 253 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 254 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 255 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 256 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 257 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 258 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 259 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 260 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 261 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 262 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 263 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 264 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 265 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 266 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 267 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 268 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 269 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 270 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 271 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 272 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 273 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 274 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 275 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 276 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 277 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 278 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 279 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 280 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 281 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 282 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 283 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 284 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 285 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 286 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 287 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 288 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 289 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 290 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 291 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 292 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 293 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 294 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 295 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 296 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 297 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 298 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 399 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 300 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 301 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 302 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 303 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 304 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 305 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 306 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 307 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 308 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 309 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 310 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 311 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 312 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 313 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 314 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 315 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 316 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 317 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 318 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 319 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 320 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 321 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 322 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 323 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 324 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 325 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 326 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 327 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 328 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 329 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 330 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 331 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 332 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 333 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 334 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 335 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 336 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 337 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 338 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 339 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 340 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 341 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 342 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 343 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 344 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 345 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 346 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 347 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 348 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 349 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 310 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 351 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 352 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 353 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 354 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 355 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 356 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 357 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 358 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 359 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 360 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 361 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 362 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 363 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 364 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 365 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 366 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 367 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 368 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 369 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 370 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 371 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 372 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 373 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 374 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 375 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 376 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 377 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 378 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 379 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 380 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 381 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 382 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 383 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 384 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 385 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 386 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 387 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 388 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 389 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 390 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 391 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 392 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 393 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 394 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 395 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 396 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 397 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 398 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 399 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 400 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 401 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 402 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 403 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 404 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 405 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 406 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 407 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 408 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 409 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 410 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 411 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 412 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 413 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 414 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 415 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 416 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 417 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 418 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 419 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 420 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 421 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 422 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 423 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 424 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 425 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 426 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 427 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 428 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 429 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 430 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 431 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 432 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 433 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 434 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 435 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 436 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 437 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 438 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 439 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 440 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 441 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 442 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 443 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 444 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 445 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 446 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 447 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 448 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 449 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 410 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 451 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 452 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 453 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 454 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 455 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 456 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 457 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 458 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 459 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 460 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 461 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 462 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 463 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 464 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 465 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 466 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 467 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 468 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 469 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 470 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 471 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 472 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 473 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 474 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 475 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 476 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 477 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 478 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 479 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 480 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 481 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 482 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 483 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 484 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 485 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 486 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 487 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 488 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 489 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 490 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 491 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 492 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 493 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 494 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 495 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 496 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 497 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 498 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 499 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 500 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 501 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 502 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 503 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 504 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 505 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 506 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 507 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 508 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 509 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 510 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 511 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 512 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 513 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 514 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 515 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 516 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 517 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 518 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 519 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 520 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 521 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 522 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 523 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 524 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 525 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 526 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 527 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 528 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 529 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 530 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 531 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 532 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 533 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 534 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 535 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 536 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 537 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 538 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 539 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 540 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 541 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 542 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 543 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 544 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 545 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 546 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 547 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 548 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 549 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 510 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 551 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 552 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 553 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 554 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 555 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 556 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 557 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 558 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 559 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 560 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 561 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 562 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 563 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 564 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 565 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 566 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 567 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 568 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 569 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 570 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 571 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 572 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 573 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 574 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 575 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 576 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 577 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 578 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 579 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 580 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 581 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 582 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 583 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 584 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 585 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 586 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 587 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 588 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 589 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 590 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 591 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 592 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 593 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 594 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 595 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 596 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 597 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 598 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 599 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 600 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 601 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 602 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 603 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 604 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 605 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 606 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 607 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 608 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 609 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 610 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 611 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 612 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 613 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 614 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 615 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 616 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 617 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 618 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 619 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 620 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 621 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 622 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 623 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 624 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 625 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 626 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 627 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 628 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 629 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 630 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 631 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 632 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 633 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 634 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 635 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 636 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 637 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 638 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 639 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 640 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 641 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 642 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 643 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 644 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 645 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 646 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 647 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 648 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 649 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 610 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 651 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 652 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 653 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 654 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 655 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 656 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 657 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 658 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 659 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 660 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 661 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 662 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 663 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 664 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 665 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 666 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 667 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 668 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 669 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 670 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 671 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 672 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 673 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 674 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 675 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 676 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 677 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 678 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 679 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 680 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 681 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 682 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 683 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 684 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 685 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 686 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 687 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 688 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 689 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 690 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 691 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 692 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 693 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 694 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 695 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 696 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 697 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 698 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 699 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 700 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 701 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 702 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 703 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 704 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 705 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 706 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 707 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 708 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 709 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 710 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 711 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 712 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 713 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 714 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 715 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 716 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 717 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 718 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 719 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 720 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 721 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 722 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 723 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 724 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 725 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 726 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 727 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 728 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 729 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 730 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 731 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 732 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 733 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 734 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 735 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 736 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 737 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 738 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 739 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 740 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 741 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 742 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 743 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 744 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 745 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 746 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 747 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 748 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 749 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 710 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 751 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 752 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 753 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 754 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 755 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 756 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 757 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 758 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 759 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 760 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 761 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 762 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 763 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 764 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 765 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 766 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 767 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 768 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 769 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 770 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 771 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 772 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 773 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 774 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 775 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 776 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 777 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 778 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 779 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 780 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 781 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 782 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 783 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 784 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 785 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 786 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 787 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 788 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 789 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 790 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 791 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 792 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 793 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 794 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 795 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 796 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 797 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 798 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 799 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 800 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 801 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 802 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 803 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 804 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 805 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 806 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 807 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 808 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 809 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 810 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 811 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 812 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 813 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 814 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 815 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 816 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 817 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 818 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 819 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 820 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 821 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 822 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 823 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 824 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 825 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 826 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 827 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 828 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 829 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 830 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 831 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 832 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 833 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 834 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 835 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 836 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 837 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 838 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 839 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 840 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 841 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 842 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 843 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 844 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 845 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 846 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 847 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 848 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 849 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 810 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 851 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 852 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 853 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 854 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 855 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 856 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 857 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 858 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 859 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 860 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 861 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 862 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 863 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 864 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 865 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 866 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 867 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 868 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 869 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 870 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 871 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 872 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 873 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 874 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 875 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 876 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 877 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 878 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 879 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 880 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 881 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 882 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 883 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 884 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 885 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 886 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 887 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 888 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 889 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 890 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 891 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 892 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 893 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 894 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 895 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 896 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 897 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 898 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 899 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 900 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 901 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 902 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 903 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 904 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 905 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 906 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 907 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 908 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 909 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 910 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 911 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 912 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 913 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 914 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 915 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 916 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 917 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 918 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 919 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 920 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 921 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 922 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 923 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 924 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 925 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 926 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 927 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 928 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 929 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 930 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 931 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 932 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 933 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 934 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 935 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 936 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 937 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 938 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 939 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 940 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 941 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 942 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 943 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 944 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 945 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 946 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 947 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 948 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 949 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 910 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 951 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 952 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 953 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 954 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 955 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 956 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 957 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 958 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 959 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 960 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 961 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 962 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 963 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 964 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 965 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 966 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 967 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 968 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 969 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 970 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 971 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 972 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 973 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 974 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 975 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 976 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 977 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 978 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 979 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 980 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 981 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 982 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 983 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 984 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 985 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 986 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 987 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 988 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 989 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 990 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 991 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 992 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 993 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 994 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 995 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 996 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 997 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 998 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 999 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA $ sed -n '$=' > 1000 p And now, a read/write test < 000 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 001 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 002 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 003 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 004 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 005 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 006 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 007 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 008 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 009 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 010 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 011 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 012 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 013 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 014 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 015 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 016 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 017 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 018 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 019 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 020 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 021 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 022 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 023 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 024 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 025 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 026 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 027 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 028 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 029 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 030 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 031 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 032 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 033 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 034 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 035 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 036 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 037 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 038 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 039 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 040 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 041 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 042 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 043 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 044 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 045 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 046 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 047 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 048 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 049 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 010 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 051 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 052 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 053 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 054 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 055 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 056 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 057 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 058 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 059 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 060 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 061 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 062 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 063 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 064 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 065 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 066 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 067 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 068 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 069 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 070 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 071 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 072 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 073 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 074 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 075 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 076 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 077 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 078 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 079 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 080 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 081 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 082 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 083 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 084 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 085 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 086 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 087 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 088 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 089 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 090 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 091 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 092 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 093 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 094 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 095 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 096 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 097 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 098 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 099 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 100 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 101 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 102 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 103 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 104 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 105 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 106 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 107 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 108 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 109 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 110 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 111 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 112 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 113 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 114 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 115 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 116 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 117 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 118 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 119 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 120 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 121 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 122 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 123 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 124 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 125 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 126 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 127 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 128 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 129 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 130 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 131 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 132 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 133 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 134 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 135 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 136 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 137 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 138 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 139 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 140 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 141 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 142 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 143 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 144 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 145 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 146 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 147 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 148 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 149 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 110 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 151 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 152 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 153 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 154 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 155 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 156 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 157 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 158 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 159 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 160 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 161 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 162 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 163 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 164 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 165 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 166 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 167 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 168 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 169 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 170 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 171 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 172 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 173 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 174 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 175 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 176 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 177 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 178 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 179 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 180 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 181 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 182 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 183 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 184 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 185 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 186 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 187 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 188 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 189 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 190 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 191 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 192 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 193 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 194 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 195 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 196 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 197 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 198 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 199 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 200 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 201 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 202 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 203 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 204 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 205 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 206 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 207 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 208 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 209 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 210 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 211 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 212 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 213 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 214 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 215 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 216 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 217 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 218 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 219 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 220 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 221 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 222 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 223 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 224 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 225 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 226 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 227 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 228 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 229 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 230 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 231 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 232 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 233 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 234 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 235 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 236 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 237 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 238 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 239 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 240 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 241 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 242 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 243 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 244 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 245 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 246 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 247 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 248 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 249 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 210 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 251 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 252 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 253 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 254 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 255 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 256 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 257 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 258 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 259 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 260 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 261 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 262 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 263 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 264 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 265 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 266 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 267 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 268 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 269 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 270 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 271 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 272 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 273 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 274 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 275 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 276 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 277 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 278 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 279 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 280 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 281 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 282 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 283 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 284 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 285 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 286 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 287 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 288 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 289 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 290 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 291 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 292 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 293 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 294 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 295 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 296 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 297 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 298 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 399 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 300 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 301 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 302 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 303 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 304 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 305 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 306 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 307 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 308 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 309 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 310 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 311 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 312 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 313 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 314 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 315 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 316 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 317 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 318 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 319 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 320 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 321 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 322 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 323 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 324 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 325 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 326 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 327 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 328 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 329 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 330 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 331 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 332 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 333 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 334 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 335 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 336 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 337 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 338 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 339 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 340 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 341 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 342 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 343 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 344 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 345 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 346 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 347 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 348 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 349 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 310 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 351 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 352 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 353 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 354 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 355 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 356 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 357 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 358 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 359 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 360 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 361 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 362 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 363 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 364 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 365 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 366 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 367 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 368 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 369 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 370 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 371 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 372 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 373 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 374 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 375 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 376 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 377 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 378 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 379 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 380 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 381 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 382 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 383 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 384 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 385 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 386 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 387 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 388 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 389 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 390 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 391 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 392 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 393 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 394 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 395 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 396 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 397 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 398 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 399 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 400 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 401 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 402 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 403 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 404 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 405 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 406 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 407 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 408 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 409 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 410 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 411 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 412 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 413 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 414 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 415 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 416 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 417 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 418 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 419 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 420 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 421 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 422 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 423 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 424 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 425 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 426 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 427 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 428 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 429 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 430 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 431 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 432 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 433 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 434 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 435 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 436 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 437 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 438 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 439 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 440 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 441 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 442 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 443 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 444 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 445 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 446 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 447 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 448 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 449 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 410 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 451 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 452 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 453 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 454 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 455 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 456 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 457 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 458 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 459 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 460 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 461 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 462 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 463 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 464 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 465 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 466 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 467 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 468 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 469 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 470 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 471 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 472 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 473 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 474 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 475 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 476 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 477 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 478 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 479 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 480 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 481 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 482 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 483 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 484 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 485 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 486 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 487 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 488 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 489 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 490 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 491 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 492 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 493 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 494 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 495 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 496 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 497 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 498 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 499 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 500 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 501 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 502 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 503 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 504 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 505 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 506 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 507 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 508 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 509 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 510 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 511 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 512 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 513 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 514 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 515 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 516 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 517 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 518 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 519 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 520 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 521 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 522 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 523 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 524 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 525 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 526 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 527 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 528 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 529 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 530 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 531 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 532 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 533 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 534 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 535 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 536 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 537 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 538 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 539 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 540 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 541 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 542 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 543 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 544 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 545 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 546 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 547 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 548 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 549 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 510 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 551 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 552 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 553 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 554 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 555 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 556 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 557 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 558 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 559 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 560 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 561 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 562 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 563 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 564 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 565 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 566 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 567 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 568 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 569 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 570 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 571 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 572 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 573 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 574 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 575 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 576 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 577 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 578 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 579 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 580 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 581 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 582 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 583 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 584 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 585 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 586 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 587 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 588 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 589 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 590 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 591 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 592 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 593 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 594 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 595 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 596 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 597 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 598 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 599 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 600 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 601 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 602 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 603 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 604 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 605 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 606 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 607 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 608 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 609 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 610 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 611 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 612 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 613 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 614 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 615 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 616 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 617 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 618 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 619 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 620 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 621 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 622 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 623 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 624 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 625 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 626 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 627 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 628 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 629 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 630 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 631 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 632 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 633 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 634 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 635 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 636 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 637 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 638 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 639 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 640 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 641 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 642 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 643 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 644 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 645 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 646 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 647 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 648 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 649 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 610 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 651 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 652 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 653 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 654 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 655 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 656 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 657 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 658 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 659 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 660 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 661 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 662 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 663 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 664 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 665 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 666 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 667 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 668 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 669 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 670 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 671 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 672 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 673 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 674 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 675 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 676 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 677 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 678 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 679 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 680 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 681 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 682 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 683 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 684 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 685 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 686 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 687 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 688 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 689 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 690 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 691 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 692 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 693 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 694 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 695 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 696 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 697 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 698 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 699 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 700 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 701 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 702 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 703 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 704 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 705 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 706 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 707 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 708 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 709 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 710 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 711 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 712 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 713 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 714 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 715 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 716 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 717 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 718 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 719 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 720 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 721 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 722 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 723 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 724 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 725 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 726 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 727 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 728 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 729 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 730 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 731 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 732 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 733 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 734 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 735 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 736 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 737 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 738 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 739 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 740 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 741 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 742 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 743 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 744 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 745 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 746 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 747 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 748 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 749 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 710 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 751 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 752 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 753 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 754 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 755 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 756 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 757 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 758 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 759 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 760 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 761 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 762 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 763 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 764 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 765 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 766 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 767 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 768 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 769 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 770 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 771 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 772 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 773 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 774 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 775 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 776 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 777 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 778 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 779 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 780 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 781 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 782 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 783 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 784 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 785 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 786 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 787 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 788 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 789 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 790 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 791 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 792 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 793 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 794 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 795 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 796 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 797 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 798 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 799 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 800 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 801 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 802 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 803 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 804 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 805 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 806 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 807 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 808 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 809 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 810 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 811 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 812 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 813 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 814 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 815 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 816 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 817 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 818 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 819 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 820 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 821 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 822 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 823 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 824 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 825 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 826 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 827 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 828 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 829 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 830 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 831 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 832 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 833 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 834 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 835 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 836 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 837 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 838 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 839 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 840 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 841 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 842 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 843 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 844 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 845 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 846 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 847 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 848 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 849 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 810 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 851 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 852 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 853 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 854 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 855 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 856 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 857 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 858 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 859 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 860 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 861 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 862 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 863 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 864 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 865 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 866 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 867 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 868 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 869 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 870 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 871 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 872 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 873 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 874 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 875 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 876 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 877 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 878 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 879 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 880 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 881 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 882 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 883 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 884 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 885 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 886 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 887 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 888 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 889 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 890 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 891 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 892 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 893 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 894 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 895 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 896 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 897 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 898 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 899 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 900 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 901 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 902 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 903 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 904 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 905 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 906 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 907 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 908 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 909 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 910 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 911 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 912 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 913 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 914 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 915 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 916 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 917 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 918 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 919 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 920 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 921 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 922 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 923 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 924 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 925 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 926 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 927 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 928 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 929 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 930 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 931 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 932 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 933 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 934 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 935 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 936 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 937 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 938 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 939 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 940 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 941 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 942 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 943 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 944 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 945 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 946 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 947 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 948 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 949 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 910 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 951 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 952 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 953 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 954 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 955 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 956 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 957 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 958 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 959 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 960 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 961 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 962 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 963 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 964 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 965 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 966 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 967 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 968 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 969 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 970 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 971 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 972 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 973 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 974 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 975 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 976 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 977 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 978 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 979 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 980 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 981 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 982 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 983 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 984 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 985 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 986 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 987 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 988 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 989 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 990 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 991 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 992 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 993 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 994 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 995 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 996 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 997 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 998 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA < 999 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA $ cat > 000 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 001 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 002 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 003 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 004 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 005 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 006 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 007 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 008 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 009 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 010 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 011 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 012 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 013 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 014 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 015 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 016 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 017 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 018 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 019 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 020 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 021 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 022 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 023 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 024 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 025 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 026 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 027 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 028 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 029 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 030 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 031 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 032 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 033 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 034 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 035 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 036 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 037 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 038 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 039 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 040 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 041 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 042 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 043 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 044 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 045 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 046 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 047 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 048 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 049 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 010 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 051 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 052 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 053 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 054 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 055 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 056 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 057 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 058 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 059 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 060 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 061 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 062 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 063 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 064 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 065 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 066 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 067 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 068 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 069 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 070 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 071 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 072 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 073 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 074 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 075 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 076 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 077 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 078 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 079 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 080 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 081 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 082 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 083 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 084 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 085 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 086 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 087 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 088 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 089 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 090 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 091 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 092 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 093 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 094 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 095 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 096 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 097 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 098 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 099 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 100 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 101 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 102 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 103 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 104 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 105 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 106 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 107 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 108 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 109 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 110 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 111 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 112 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 113 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 114 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 115 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 116 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 117 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 118 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 119 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 120 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 121 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 122 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 123 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 124 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 125 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 126 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 127 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 128 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 129 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 130 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 131 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 132 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 133 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 134 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 135 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 136 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 137 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 138 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 139 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 140 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 141 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 142 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 143 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 144 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 145 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 146 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 147 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 148 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 149 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 110 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 151 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 152 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 153 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 154 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 155 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 156 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 157 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 158 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 159 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 160 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 161 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 162 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 163 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 164 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 165 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 166 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 167 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 168 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 169 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 170 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 171 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 172 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 173 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 174 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 175 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 176 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 177 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 178 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 179 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 180 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 181 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 182 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 183 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 184 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 185 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 186 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 187 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 188 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 189 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 190 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 191 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 192 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 193 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 194 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 195 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 196 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 197 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 198 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 199 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 200 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 201 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 202 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 203 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 204 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 205 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 206 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 207 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 208 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 209 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 210 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 211 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 212 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 213 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 214 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 215 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 216 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 217 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 218 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 219 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 220 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 221 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 222 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 223 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 224 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 225 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 226 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 227 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 228 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 229 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 230 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 231 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 232 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 233 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 234 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 235 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 236 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 237 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 238 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 239 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 240 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 241 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 242 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 243 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 244 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 245 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 246 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 247 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 248 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 249 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 210 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 251 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 252 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 253 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 254 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 255 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 256 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 257 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 258 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 259 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 260 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 261 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 262 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 263 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 264 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 265 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 266 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 267 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 268 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 269 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 270 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 271 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 272 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 273 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 274 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 275 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 276 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 277 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 278 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 279 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 280 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 281 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 282 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 283 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 284 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 285 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 286 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 287 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 288 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 289 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 290 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 291 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 292 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 293 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 294 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 295 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 296 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 297 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 298 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 399 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 300 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 301 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 302 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 303 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 304 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 305 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 306 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 307 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 308 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 309 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 310 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 311 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 312 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 313 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 314 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 315 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 316 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 317 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 318 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 319 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 320 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 321 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 322 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 323 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 324 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 325 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 326 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 327 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 328 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 329 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 330 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 331 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 332 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 333 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 334 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 335 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 336 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 337 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 338 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 339 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 340 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 341 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 342 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 343 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 344 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 345 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 346 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 347 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 348 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 349 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 310 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 351 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 352 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 353 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 354 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 355 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 356 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 357 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 358 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 359 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 360 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 361 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 362 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 363 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 364 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 365 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 366 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 367 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 368 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 369 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 370 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 371 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 372 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 373 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 374 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 375 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 376 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 377 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 378 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 379 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 380 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 381 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 382 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 383 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 384 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 385 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 386 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 387 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 388 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 389 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 390 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 391 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 392 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 393 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 394 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 395 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 396 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 397 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 398 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 399 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 400 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 401 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 402 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 403 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 404 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 405 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 406 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 407 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 408 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 409 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 410 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 411 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 412 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 413 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 414 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 415 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 416 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 417 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 418 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 419 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 420 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 421 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 422 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 423 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 424 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 425 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 426 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 427 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 428 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 429 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 430 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 431 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 432 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 433 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 434 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 435 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 436 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 437 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 438 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 439 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 440 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 441 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 442 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 443 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 444 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 445 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 446 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 447 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 448 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 449 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 410 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 451 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 452 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 453 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 454 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 455 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 456 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 457 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 458 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 459 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 460 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 461 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 462 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 463 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 464 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 465 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 466 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 467 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 468 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 469 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 470 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 471 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 472 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 473 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 474 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 475 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 476 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 477 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 478 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 479 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 480 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 481 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 482 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 483 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 484 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 485 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 486 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 487 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 488 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 489 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 490 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 491 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 492 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 493 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 494 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 495 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 496 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 497 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 498 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 499 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 500 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 501 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 502 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 503 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 504 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 505 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 506 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 507 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 508 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 509 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 510 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 511 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 512 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 513 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 514 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 515 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 516 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 517 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 518 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 519 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 520 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 521 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 522 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 523 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 524 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 525 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 526 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 527 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 528 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 529 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 530 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 531 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 532 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 533 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 534 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 535 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 536 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 537 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 538 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 539 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 540 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 541 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 542 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 543 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 544 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 545 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 546 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 547 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 548 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 549 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 510 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 551 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 552 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 553 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 554 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 555 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 556 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 557 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 558 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 559 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 560 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 561 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 562 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 563 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 564 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 565 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 566 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 567 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 568 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 569 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 570 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 571 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 572 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 573 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 574 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 575 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 576 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 577 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 578 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 579 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 580 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 581 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 582 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 583 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 584 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 585 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 586 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 587 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 588 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 589 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 590 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 591 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 592 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 593 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 594 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 595 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 596 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 597 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 598 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 599 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 600 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 601 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 602 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 603 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 604 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 605 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 606 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 607 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 608 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 609 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 610 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 611 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 612 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 613 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 614 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 615 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 616 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 617 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 618 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 619 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 620 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 621 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 622 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 623 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 624 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 625 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 626 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 627 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 628 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 629 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 630 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 631 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 632 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 633 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 634 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 635 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 636 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 637 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 638 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 639 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 640 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 641 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 642 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 643 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 644 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 645 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 646 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 647 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 648 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 649 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 610 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 651 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 652 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 653 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 654 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 655 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 656 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 657 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 658 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 659 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 660 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 661 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 662 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 663 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 664 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 665 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 666 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 667 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 668 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 669 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 670 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 671 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 672 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 673 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 674 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 675 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 676 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 677 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 678 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 679 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 680 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 681 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 682 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 683 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 684 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 685 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 686 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 687 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 688 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 689 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 690 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 691 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 692 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 693 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 694 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 695 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 696 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 697 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 698 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 699 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 700 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 701 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 702 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 703 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 704 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 705 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 706 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 707 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 708 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 709 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 710 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 711 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 712 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 713 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 714 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 715 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 716 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 717 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 718 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 719 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 720 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 721 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 722 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 723 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 724 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 725 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 726 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 727 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 728 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 729 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 730 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 731 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 732 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 733 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 734 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 735 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 736 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 737 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 738 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 739 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 740 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 741 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 742 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 743 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 744 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 745 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 746 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 747 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 748 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 749 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 710 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 751 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 752 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 753 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 754 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 755 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 756 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 757 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 758 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 759 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 760 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 761 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 762 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 763 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 764 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 765 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 766 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 767 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 768 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 769 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 770 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 771 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 772 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 773 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 774 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 775 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 776 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 777 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 778 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 779 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 780 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 781 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 782 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 783 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 784 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 785 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 786 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 787 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 788 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 789 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 790 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 791 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 792 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 793 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 794 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 795 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 796 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 797 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 798 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 799 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 800 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 801 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 802 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 803 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 804 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 805 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 806 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 807 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 808 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 809 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 810 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 811 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 812 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 813 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 814 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 815 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 816 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 817 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 818 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 819 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 820 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 821 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 822 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 823 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 824 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 825 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 826 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 827 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 828 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 829 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 830 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 831 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 832 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 833 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 834 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 835 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 836 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 837 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 838 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 839 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 840 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 841 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 842 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 843 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 844 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 845 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 846 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 847 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 848 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 849 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 810 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 851 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 852 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 853 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 854 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 855 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 856 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 857 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 858 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 859 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 860 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 861 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 862 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 863 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 864 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 865 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 866 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 867 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 868 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 869 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 870 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 871 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 872 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 873 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 874 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 875 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 876 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 877 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 878 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 879 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 880 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 881 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 882 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 883 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 884 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 885 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 886 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 887 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 888 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 889 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 890 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 891 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 892 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 893 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 894 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 895 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 896 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 897 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 898 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 899 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 900 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 901 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 902 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 903 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 904 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 905 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 906 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 907 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 908 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 909 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 910 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 911 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 912 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 913 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 914 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 915 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 916 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 917 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 918 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 919 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 920 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 921 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 922 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 923 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 924 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 925 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 926 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 927 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 928 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 929 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 930 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 931 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 932 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 933 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 934 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 935 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 936 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 937 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 938 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 939 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 940 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 941 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 942 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 943 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 944 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 945 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 946 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 947 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 948 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 949 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 910 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 951 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 952 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 953 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 954 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 955 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 956 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 957 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 958 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 959 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 960 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 961 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 962 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 963 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 964 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 965 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 966 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 967 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 968 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 969 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 970 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 971 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 972 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 973 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 974 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 975 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 976 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 977 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 978 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 979 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 980 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 981 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 982 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 983 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 984 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 985 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 986 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 987 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 988 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 989 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 990 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 991 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 992 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 993 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 994 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 995 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 996 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 997 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 998 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA > 999 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA SimGrid-3.11/tools/tesh/catch-wrong-output.tesh000644 001750 001750 00000000523 12342443665 020577 0ustar00cici000000 000000 #! ./tesh p This tests whether TESH detects wrong outputs ! expect return 2 < > TOTO < < TUTU < $ cat $ ./tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' > Enable coverage > Test suite from stdin > [(stdin):3] cat > Output of <(stdin):3> mismatch: > - TOTO > + TUTU > Test suite `(stdin)': NOK (<(stdin):3> output mismatch) SimGrid-3.11/tools/tesh/IO-broken-pipe.tesh000644 001750 001750 00000002276 12342443665 017554 0ustar00cici000000 000000 # TESH autotest: check that the father is protected from broken pipes # # If not, it breaks sometimes (when the child is scheduled before the # father), so we do the test a bunch of times. # < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo < blablablablablablablablablablablablablablablablablablablabla > $ echo SimGrid-3.11/tools/tesh/colorize.pl000755 001750 001750 00000000737 12342443657 016336 0ustar00cici000000 000000 #!/usr/bin/perl -w # Copyright (c) 2010, 2014. The SimGrid Team. # All rights reserved. # This program is free software; you can redistribute it and/or modify it # under the terms of the license (GNU LGPL) which comes with this package. use Term::ANSIColor qw{:constants}; $Term::ANSIColor::AUTORESET = 1; while(<>){ if($_ =~ m/^(\d+\:\s)?[-]\s.*/){ print BOLD RED $_; }elsif ($_ =~ m/^(\d+\:\s)?[+]\s.*/){ print BOLD GREEN $_; }else{ print BOLD $_; } } SimGrid-3.11/tools/tesh/set-return.tesh000644 001750 001750 00000000613 12342443665 017135 0ustar00cici000000 000000 #! ./tesh # This suite builds and uses a program returning 1. # tesh is instructed of this return code and must not whine. $ rm -rf temp_testdir-set-return $ mkdir temp_testdir-set-return $ cd temp_testdir-set-return < #include < int main(void) { < exit(1); < } $ mkfile return1.c $ cc -o return1 return1.c ! expect return 1 $ ./return1 $ cd .. $ rm -rf temp_testdir-set-return SimGrid-3.11/tools/tesh/catch-timeout.tesh000644 001750 001750 00000000656 12342443665 017602 0ustar00cici000000 000000 #! ./tesh # This suite must be functional because we changed the timeout value to 10 # before sleeping 6 secs. ! expect return 3 < ! timeout 1 < $ sleep 6 > Enable coverage > Test suite from stdin > [(stdin):2] sleep 6 > <(stdin):2> timeouted. Kill the process. > <(stdin):2> No output before timeout > Test suite `(stdin)': NOK (<(stdin):2> timeout after 1 sec) $ ./tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' SimGrid-3.11/tools/tesh/signal.c000644 001750 001750 00000003201 12342443666 015556 0ustar00cici000000 000000 /* signal -- what TESH needs to know about signals */ /* Copyright (c) 2007-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "tesh.h" #include typedef struct s_signal_entry { const char *name; int number; } s_signal_entry_t, *signal_entry_t; static const s_signal_entry_t signals[] = { {"SIGHUP", SIGHUP}, {"SIGINT", SIGINT}, {"SIGQUIT", SIGQUIT}, {"SIGILL", SIGILL}, {"SIGTRAP", SIGTRAP}, {"SIGABRT", SIGABRT}, {"SIGFPE", SIGFPE}, {"SIGKILL", SIGKILL}, {"SIGBUS", SIGBUS}, {"SIGSEGV", SIGSEGV}, {"SIGSYS", SIGSYS}, {"SIGPIPE", SIGPIPE}, {"SIGALRM", SIGALRM}, {"SIGTERM", SIGTERM}, {"SIGURG", SIGURG}, {"SIGSTOP", SIGSTOP}, {"SIGTSTP", SIGTSTP}, {"SIGCONT", SIGCONT}, {"SIGCHLD", SIGCHLD}, {"SIGTTIN", SIGTTIN}, {"SIGTTOU", SIGTTOU}, {"SIGIO", SIGIO}, {"SIGXCPU", SIGXCPU}, {"SIGXFSZ", SIGXFSZ}, {"SIGVTALRM", SIGVTALRM}, {"SIGPROF", SIGPROF}, {"SIGWINCH", SIGWINCH}, {"SIGUSR1", SIGUSR1}, {"SIGUSR2", SIGUSR2}, {"SIG UNKNOWN", -1} }; const char *signal_name(int got, char *expected) { int i; /* Make SIGBUS a synonym for SIGSEGV (segfault leads to any of them depending on the system) */ if ((got == SIGBUS) && !strcmp("SIGSEGV", expected)) got = SIGSEGV; for (i = 0; signals[i].number != -1; i++) if (signals[i].number == got) return (signals[i].name); return bprintf("SIG UNKNOWN (%u)", got); } SimGrid-3.11/tools/tesh/set-timeout.tesh000644 001750 001750 00000000210 12342443665 017275 0ustar00cici000000 000000 #! ./tesh # This suite must be functional because we changed the timeout value to 10 # before sleeping 6 secs. ! timeout 10 $ sleep 6 SimGrid-3.11/tools/tesh/bg-basic.tesh000644 001750 001750 00000000216 12342443665 016473 0ustar00cici000000 000000 #! ./tesh p This is a basic test < TOTO \ TUTU & cat > TOTO TUTU p And now, some multilines examples < a < b < c < d & cat > a > b > c > dSimGrid-3.11/tools/tesh/background.tesh000644 001750 001750 00000001721 12342443665 017145 0ustar00cici000000 000000 $ rm -rf temp_testdir_background $ mkdir temp_testdir_background $ cd temp_testdir_background < #include < #include < #include < #include < #include < #include < #ifdef WIN32 < #include "windows.h" < #endif < < int main() { < char buff[2048]; < int got; < int in; < < #ifndef WIN32 < sleep(1); < #else < Sleep(1000); < #endif < in = open("tmp_fich",O_RDONLY|O_CREAT); < if (in == -1) { < perror("Cannot open tmp_fich: "); < exit(1); < } < while ((got = read(in,&buff,2048))>0) { < int w = write(1,&buff,got); < if (w<0) { < perror("Error while writing:"); < exit(1); < } < } < if (got < 0) { < perror("Error while reading:"); < exit(1); < } < return 0; < } $ mkfile delayed_cat.c $ cc -Wall -o delayed_cat delayed_cat.c & ./delayed_cat > TOTO < TOTO $ mkfile tmp_fich $ sleep 2 $ cd .. $ rm -rf temp_testdir_background SimGrid-3.11/tools/tesh/run_context.h000644 001750 001750 00000005450 12342443666 016666 0ustar00cici000000 000000 /* run_context -- stuff in which TESH runs a command */ /* Copyright (c) 2007-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef TESH_RUN_CONTEXT_H #define TESH_RUN_CONTEXT_H #include "tesh.h" #include "xbt/synchro_core.h" typedef enum { e_output_check, e_output_display, e_output_ignore } e_output_handling_t; typedef struct { /* kind of job */ char *cmd; char **env; int env_size; char *filepos; int pid; unsigned is_background:1; unsigned is_empty:1; unsigned is_stoppable:1; unsigned brokenpipe:1; unsigned timeout:1; unsigned reader_done:1; /* reader set this to true when he's done because the child is dead. The main thread use it to detect that the child is not dead before the end of timeout */ unsigned interrupted:1; /* Whether we got stopped by an armageddon */ xbt_os_mutex_t interruption; /* To allow main thread to kill a runner one only at certain points */ e_output_handling_t output; int status; /* expected results */ int end_time; /* begin_time + timeout, as epoch */ char *expected_signal; /* name of signal to raise (or NULL if none) */ int expected_return; /* the exepeted return code of following command */ unsigned output_sort:1; /* whether the output must be sorted before comparison */ /* buffers */ xbt_strbuff_t input; xbt_strbuff_t output_wanted; xbt_strbuff_t output_got; /* Threads */ xbt_os_thread_t writer, reader; /* IO handlers */ xbt_os_thread_t runner; /* Main thread, counting for timeouts */ /* Pipes from/to the child */ int child_to, child_from; } s_rctx_t, *rctx_t; /* module mgmt */ void rctx_init(void); void rctx_exit(void); /* wait for all currently running background jobs */ void rctx_wait_bg(void); /* kill forcefully all currently running background jobs */ extern rctx_t armageddon_initiator; extern xbt_os_mutex_t armageddon_mutex; void rctx_armageddon(rctx_t initiator, int exitcode); /* create a new empty running context */ rctx_t rctx_new(void); void rctx_free(rctx_t rctx); void rctx_empty(rctx_t rc); /*reset to empty */ void rctx_dump(rctx_t rctx, const char *str); /* Launch the current command */ void rctx_start(void); /* Wait till the end of this command */ void *rctx_wait(void *rctx); /* Parse a line comming from the suite file, and add this into the rctx */ void rctx_pushline(const char *filepos, char kind, char *line); #endif /* TESH_RUN_CONTEXT_H */ SimGrid-3.11/tools/tesh/setenv.tesh000644 001750 001750 00000001206 12342443665 016330 0ustar00cici000000 000000 #! ./tesh # This suite builds and uses a program returning 1. # tesh is instructed of this return code and must not whine. $ rm -rf temp_testdir-setenv $ mkdir temp_testdir-setenv $ cd temp_testdir-setenv < #include < #include < extern char **environ; < int main(void) { < char **env_iter=environ; < while (*env_iter) { < if (!strncmp(*env_iter,"tesh_test_toto=",strlen("tesh_test_toto="))) < printf("%s\n",*env_iter); < env_iter++; < } < return 0; < } $ mkfile getenv.c $ cc -o getenv getenv.c -g ! setenv tesh_test_toto=blah $ ./getenv > tesh_test_toto=blah $ cd .. $ rm -rf temp_testdir-setenv SimGrid-3.11/tools/tesh/set-output-sort-1.tesh000644 001750 001750 00000001463 12342443665 020305 0ustar00cici000000 000000 p Test sorting and filtering of output $ true ! output sort $ true $ printf 'profiling: foo\\n' $ printf 'profiling: foo' ! output sort $ printf 'profiling: foo\\n' ! output sort $ printf 'profiling: foo' $ printf 'a\\nb\\nc\\nd\\n' > a > b > c > d $ printf 'a\\nb\\nc\\nd' > a > b > c > d ! output sort $ printf 'c\\nd\\nb\\na\\n' > a > b > c > d ! output sort $ printf 'c\\nd\\nb\\na' > a > b > c > d $ printf 'a\\nprofiling: foo\\nprofiling: bar\\nb\\nc\\nd\\nprofiling: baz\\n' > a > b > c > d $ printf 'a\\nprofiling: foo\\nprofiling: bar\\nb\\nc\\nd\\nprofiling: baz' > a > b > c > d ! output sort $ printf 'c\\nprofiling: foo\\nprofiling: bar\\nd\\nb\\na\\nprofiling: baz\\n' > a > b > c > d ! output sort $ printf 'c\\nprofiling: foo\\nprofiling: bar\\nd\\nb\\na\\nprofiling: baz' > a > b > c > d SimGrid-3.11/tools/tesh/set-signal.tesh000644 001750 001750 00000000705 12342443665 017075 0ustar00cici000000 000000 #! ./tesh # This suite builds and uses a program raising a segfault, ie a program dying # of SIGSEV. tesh must detect this condition and report the issue. $ rm -rf temp_testdir-set-signal $ mkdir temp_testdir-set-signal $ cd temp_testdir-set-signal < #include < int main(void) { < char *A=NULL; < *A = 1; < } $ mkfile segfault.c $ cc -o segfault segfault.c ! expect signal SIGSEGV $ ./segfault $ cd .. $ rm -rf temp_testdir-set-signal SimGrid-3.11/tools/tesh/catch-return.tesh000644 001750 001750 00000001165 12342443665 017427 0ustar00cici000000 000000 #! ./tesh # This suite builds and uses a program returning 1. # tesh must detect this condition and report the issue. $ rm -rf temp_testdir-catch-return $ mkdir temp_testdir-catch-return $ cd temp_testdir-catch-return < #include < int main(void) { < exit(1); < } $ mkfile return1.c $ cc -o return1 return1.c ! expect return 41 < $ ./return1 $ ../tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' > Enable coverage > Test suite from stdin > [(stdin):1] ./return1 > Test suite `(stdin)': NOK (<(stdin):1> returned code 1) > Output of <(stdin):1> so far: > || $ cd .. $ rm -rf temp_testdir-catch-return SimGrid-3.11/tools/tesh/cd.tesh000644 001750 001750 00000001253 12342443665 015414 0ustar00cici000000 000000 #! ./tesh # This example uses the cd command $ rm -rf testdir_temp-cd $ mkdir testdir_temp-cd $ cd testdir_temp-cd # Check that there is nothing in the current dir (which must be testdir_temp-cd) $ ls # Check that tesh detects properly cd to non-existing directories ! expect return 4 < $ cd toto > Enable coverage > Test suite from stdin > Chdir to toto failed: No such file or directory > Test suite `(stdin)': NOK (system error) $ ../tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' # The next command checks that there is a testdir_temp-cd in the upper directory, # ie that mkdir and cd both worked. $ test -e ../testdir_temp-cd $ cd .. $ rmdir testdir_temp-cd SimGrid-3.11/tools/tesh/set-output-ignore.tesh000644 001750 001750 00000000477 12342443665 020447 0ustar00cici000000 000000 #! ./tesh p This tests whether TESH accepts to ignore command output < ! output ignore < > TOTO < < TUTU < $ cat $ ./tesh --enable-coverage --log='log.thresh:info tesh.fmt:%m%n' > Enable coverage > Test suite from stdin > [(stdin):4] cat > (ignoring the output of <(stdin):4> as requested) > Test suite from stdin OK SimGrid-3.11/tools/tesh/README000644 001750 001750 00000012272 12342443666 015025 0ustar00cici000000 000000 This is the TESH tool. It constitutes a testing shell, ie a sort of shell specialized to run tests. The list of actions to take is parsed from files files called testsuite. Testsuites syntax ----------------- Here is the syntax of these files: The kind of each line is given by the first char (the second char should be blank and is ignored): `$' command to run in foreground `&' command to run in background `<' input to pass to the command `>' output expected from the command `!' metacommand, which can be one of: `timeout' |no `expect signal' `expect return' `output' `setenv =' `p' a string to print `P' a string to print at the CRITICAL level (ease logging grepping) If the expected output do not match what the command spits, TESH will produce an error showing the diff (see OUTPUT below). Command line arguments ---------------------- Tesh accepts several command line arguments: --cd some/directory : ask tesh to switch the working directory before launching the tests --setenv var=value : set a specific environment variable --cfg arg : add parameter --cfg=arg to each command line --enable-coverage : ignore output lines starting with "profiling:" IO orders --------- The < and > lines add IO to the command defined in the current block (blocks are separated by blank lines). It is possible to place these lines either after the command or before. The difference between the two following chunks is mainly cosmetic in your testsuites, TESH don't care. (cf IO-orders.tesh) $ cat < TOTO > TOTO > TOTO $ cat < TOTO Nevertheless, it is possible to have several commands in the same block, but none of them can have any output. It may seem a bit restrictive, as one could say that a command gets all the IO until the next command, but I'm afraid of errors such as the following: $ cd toto > TOTO $ mkfile file TOTO will be passed to the cd command, where the user clearly want to pass it to the mkfile built-in command (see below). Stream redirection ------------------ Stream redirections (">", "<" and "|" constructs in sh) are not implemented yet in tesh. This is a bit restrictive, but well, patch welcome... The situation in which it is mainly problematic is to create a temporary file. The solution is to use the "mkfile" built-in command, as in the following example: $ mkfile myFile > some content > to the file This will create a file called myFile (first argument of the mkfile command). Its content will be all the input provided to the command. RETURN CODE ----------- TESH spits an appropriate error message when the child do not return 0 as return code (cf. catch-return.tesh), and returns code+40 itself. It is also possible to specify that a given command must return another value. For this, use the "expect return" metacommand, which takes an integer as argument. The change only apply to the next command (cf. set-return.tesh). SIGNALS ------- TESH detects when the child is killed by a signal (like on segfaults), and spits an appropriate error message (cf. catch-signal.tesh). It is also possible to specify that a given command must raise a given signal. For this, use the "expect signal" metacommand. It takes the signal name as argument. The change only apply to the next command (cf. set-signal.tesh). TIMEOUTS -------- By default, all commands are given 5 seconds to execute (cf. catch-timeout.tesh). You can change this with the "timeout", which takes an integer as argument. The change only apply to the next command (cf. set-timeout.tesh). If you pass "no" as argument, the command cannot timeout. OUTPUT ------ By default, the commands output is matched against the one expected, and an error is raised on discrepancy. Metacommands to change this: "output ignore" -> output completely discarded "output display" -> output displayed (but not verified) "output sort" -> sorts the display before verifying it (see below) SORTING OUTPUT -------------- Sorting the output seems to be a strange idea, but it is mandatory in SimGrid since the processes run out of order at any scheduling point (ie, every processes ready to run at simulated time t run in parallel). To ensure that the simulator outputs still match, we have to sort the output back before comparing it. We expect the simulators to run with that log formatting argument: -log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n Then, tesh sorts string on the 19 first chars only, and is stable when line beginnings are equal. This should ensure that: (1) tesh is effective (no false positive, no false negative) (2) scheduling points are separated from each other (3) at each scheduling point, processes are separated from each other (4) the order of what a given process says at a given scheduling point is preserved. This is of course very SimGrid oriented, breaking the generality of tesh, but who cares, actually? If you want to change the length of the prefix used for the sort, simply specify it after the output sort directive, like this: ! output sort 22 ENVIRONMENT ----------- You can add some content to the tested processes environment with the setenv metacommand. It works as expected. For example: "setenv PATH=/bin"SimGrid-3.11/tools/tesh/tesh.1000644 001750 001750 00000012325 12342443666 015171 0ustar00cici000000 000000 .\" Manpage for tesh .TH tesh 1 "10 Oct 2012" "1.0" "tesh man page" .SH NAME tesh \- testing shell .SH SYNOPSIS .B tesh [\fIOPTION\fR]... [\fIFILE\fR]... .SH DESCRIPTION This is the TESH tool. It constitutes a testing shell, ie a sort of shell specialized to run tests. The list of actions to take is parsed from files files called testsuite. .SH OPTIONS --cd some/directory : ask tesh to switch the working directory before launching the tests --setenv var=value : set a specific environment variable --cfg arg : add parameter --cfg=arg to each command line --enable-coverage : ignore output lines starting with "profiling:" .SH TESH FILE SYNTAX Here is the syntax of these files: The kind of each line is given by the first char (the second char should be blank and is ignored): `$' command to run in foreground `&' command to run in background `<' input to pass to the command `>' output expected from the command `!' metacommand, which can be one of: `timeout' |no `expect signal' `expect return' `output' `setenv =' `p' a string to print `P' a string to print at the CRITICAL level (ease logging grepping) If the expected output do not match what the command spits, TESH will produce an error showing the diff (see OUTPUT below). .SH IO ORDERS The < and > lines add IO to the command defined in the current block (blocks are separated by blank lines). It is possible to place these lines either after the command or before. The difference between the two following chunks is mainly cosmetic in your testsuites, TESH don't care. (cf IO-orders.tesh) $ cat < TOTO > TOTO > TOTO $ cat < TOTO Nevertheless, it is possible to have several commands in the same block, but none of them can have any output. It may seem a bit restrictive, as one could say that a command gets all the IO until the next command, but I'm afraid of errors such as the following: $ cd toto > TOTO $ mkfile file TOTO will be passed to the cd command, where the user clearly want to pass it to the mkfile built-in command (see below). .SH STREAM REDIRECTION Stream redirections (">", "<" and "|" constructs in sh) are not implemented yet in tesh. This is a bit restrictive, but well, patch welcome... The situation in which it is mainly problematic is to create a temporary file. The solution is to use the "mkfile" built-in command, as in the following example: $ mkfile myFile > some content > to the file This will create a file called myFile (first argument of the mkfile command). Its content will be all the input provided to the command. .SH RETURN CODE TESH spits an appropriate error message when the child do not return 0 as return code (cf. catch-return.tesh), and returns code+40 itself. It is also possible to specify that a given command must return another value. For this, use the "expect return" metacommand, which takes an integer as argument. The change only apply to the next command (cf. set-return.tesh). .SH SIGNALS TESH detects when the child is killed by a signal (like on segfaults), and spits an appropriate error message (cf. catch-signal.tesh). It is also possible to specify that a given command must raise a given signal. For this, use the "expect signal" metacommand. It takes the signal name as argument. The change only apply to the next command (cf. set-signal.tesh). .SH TIMEOUTS By default, all commands are given 5 seconds to execute (cf. catch-timeout.tesh). You can change this with the "timeout", which takes an integer as argument. The change only apply to the next command (cf. set-timeout.tesh). If you pass "no" as argument, the command cannot timeout. .SH OUTPUT By default, the commands output is matched against the one expected, and an error is raised on discrepancy. Metacommands to change this: "output ignore" -> output completely discarded "output display" -> output displayed (but not verified) "output sort" -> sorts the display before verifying it (see below) .SH SORTING OUTPUT Sorting the output seems to be a strange idea, but it is mandatory in SimGrid since the processes run out of order at any scheduling point (ie, every processes ready to run at simulated time t run in parallel). To ensure that the simulator outputs still match, we have to sort the output back before comparing it. We expect the simulators to run with that log formatting argument: --log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n Then, tesh sorts string on the 19 first chars only, and is stable when line beginnings are equal. This should ensure that: (1) tesh is effective (no false positive, no false negative) (2) scheduling points are separated from each other (3) at each scheduling point, processes are separated from each other (4) the order of what a given process says at a given scheduling point is preserved. This is of course very SimGrid oriented, breaking the generality of tesh, but who cares, actually? If you want to change the length of the prefix used for the sort, simply specify it after the output sort directive, like this: ! output sort 22 .SH ENVIRONMENT You can add some content to the tested processes environment with the setenv metacommand. It works as expected. For example: "setenv PATH=/bin" .SH BUGS No known bugs. SimGrid-3.11/tools/tesh/basic.tesh000644 001750 001750 00000003202 12342443665 016103 0ustar00cici000000 000000 #! ./tesh p This is a basic test < TOTO \ TUTU $ mkfile tmp_fich $ cat tmp_fich > TOTO TUTU ! expect return 2 ! output ignore < $ cat tmp_fich < > TUTU TOTO $ ${bindir:=.}/tesh --enable-coverage $ rm tmp_fich p And now, some multilines examples p Really basic multiline < a < b < c < d $ mkfile tmp_fich $ cat tmp_fich > a > b > c > d $ sed -n '$=' tmp_fich > 4 $ rm tmp_fich p Now, check for spaces in input p * leading and trailing spaces... < a < b < c $ sed 's/ /_/g' > __a > _b_ > c__ p * empty lines... < a < < c $ sed '2s/^/b/' > a > b > c < < b < c $ sed '1s/^/a/' > a > b > c p Now that input should be good, check for spaces in output p * leading spaces... < _x $ sed 's/_/ /' > x ! expect return 2 ! output ignore < < _x < $ sed 's/_/ /' < > x $ ${bindir:=.}/tesh --enable-coverage ! expect return 2 ! output ignore < < x < $ cat < > x $ ${bindir:=.}/tesh --enable-coverage p * trailing spaces... < x_ $ sed 's/_/ /' > x ! expect return 2 ! output ignore < < x_ < $ sed 's/_/ /' < > x $ ${bindir:=.}/tesh --enable-coverage ! expect return 2 ! output ignore < < x < $ cat < > x $ ${bindir:=.}/tesh --enable-coverage p * empty lines... < a < < c $ cat > a > > c ! expect return 2 ! output ignore < < a < < < < c < $ cat < > a < > c $ ${bindir:=.}/tesh --enable-coverage ! expect return 2 ! output ignore < < a < < c < $ cat < > a < > < > c $ ${bindir:=.}/tesh --enable-coverage < < b < c $ cat > > b > c ! expect return 2 ! output ignore < < < < b < < c < $ cat < > b < > c $ ${bindir:=.}/tesh --enable-coverage ! expect return 2 ! output ignore < < b < < c < $ cat < > < > b < > c $ ${bindir:=.}/tesh --enable-coverage SimGrid-3.11/tools/tesh/CMakeLists.txt000644 001750 001750 00000004527 12342443654 016706 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(WIN32) # add_custom_target(tesh ALL # DEPENDS ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Scripts/tesh.pl # COMMENT "Install ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Scripts/tesh.pl" # COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Scripts/tesh.pl ${CMAKE_BINARY_DIR}/bin/tesh # ) configure_file("${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Scripts/tesh.pl" "${CMAKE_BINARY_DIR}/bin/tesh" @ONLY IMMEDIATE) file(COPY ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Scripts/Diff.pm DESTINATION ${CMAKE_BINARY_DIR}/bin FILE_PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ) else() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/bin") add_executable(tesh tesh.c run_context.c signal.c) ### Add definitions for compile target_link_libraries(tesh simgrid m pthread) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/setenv.tesh ${CMAKE_CURRENT_SOURCE_DIR}/set-output-ignore.tesh ${CMAKE_CURRENT_SOURCE_DIR}/set-output-sort.tesh ${CMAKE_CURRENT_SOURCE_DIR}/set-output-sort-1.tesh ${CMAKE_CURRENT_SOURCE_DIR}/set-return.tesh ${CMAKE_CURRENT_SOURCE_DIR}/set-signal.tesh ${CMAKE_CURRENT_SOURCE_DIR}/set-timeout.tesh ${CMAKE_CURRENT_SOURCE_DIR}/background.tesh ${CMAKE_CURRENT_SOURCE_DIR}/basic.tesh ${CMAKE_CURRENT_SOURCE_DIR}/bg-basic.tesh ${CMAKE_CURRENT_SOURCE_DIR}/bg-set-signal.tesh ${CMAKE_CURRENT_SOURCE_DIR}/catch-return.tesh ${CMAKE_CURRENT_SOURCE_DIR}/catch-signal.tesh ${CMAKE_CURRENT_SOURCE_DIR}/catch-timeout.tesh ${CMAKE_CURRENT_SOURCE_DIR}/catch-wrong-output.tesh ${CMAKE_CURRENT_SOURCE_DIR}/cd.tesh ${CMAKE_CURRENT_SOURCE_DIR}/IO-bigsize.tesh ${CMAKE_CURRENT_SOURCE_DIR}/IO-broken-pipe.tesh ${CMAKE_CURRENT_SOURCE_DIR}/IO-orders.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(tools_src ${tools_src} ${CMAKE_CURRENT_SOURCE_DIR}/run_context.c ${CMAKE_CURRENT_SOURCE_DIR}/run_context.h ${CMAKE_CURRENT_SOURCE_DIR}/signal.c ${CMAKE_CURRENT_SOURCE_DIR}/tesh.c ${CMAKE_CURRENT_SOURCE_DIR}/tesh.h PARENT_SCOPE ) set(bin_files ${bin_files} ${CMAKE_CURRENT_SOURCE_DIR}/colorize.pl PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/README ${CMAKE_CURRENT_SOURCE_DIR}/tesh.1 PARENT_SCOPE ) SimGrid-3.11/tools/sg_unit_extractor.pl000755 001750 001750 00000023166 12342443657 017311 0ustar00cici000000 000000 #! /usr/bin/perl # Copyright (c) 2005-2012, 2014. The SimGrid Team. # All rights reserved. # This program is free software; you can redistribute it and/or modify it # under the terms of the license (GNU LGPL) which comes with this package. use strict; use strict; use Getopt::Long qw(GetOptions); my $progname="sg_unit_extractor"; # Get the args sub usage($) { my $ret; print "USAGE: $progname [--root=part/to/cut] [--path=where/to/search NOT WORKING] [--outdir=where/to/generate/files] infile [infile+]\n"; exit $ret; } my $path=undef; my $outdir=undef; my $root; my $help; Getopt::Long::config('permute','no_getopt_compat', 'no_auto_abbrev'); GetOptions( 'help|h' => sub {usage(0)}, 'root=s' =>\$root, 'path=s' =>\$path, 'outdir=s' =>\$outdir) or usage(1); usage(1) if (scalar @ARGV == 0); map {process_one($_)} @ARGV; sub process_one($) { my $infile = shift; my $outfile; $infile =~ s|src/|| unless (-e $infile); $outfile = $infile; $outfile =~ s/\.c$/_unit.c/; $outfile =~ s|.*/([^/]*)$|$1| if $outfile =~ m|/|; $outfile = "$outdir$outfile"; print "$progname: processing $infile (generating $outfile)...\n"; # Get the unit data my ($unit_source,$suite_name,$suite_title)=("","",""); my (%tests); # to detect multiple definition my (@tests); # actual content open IN, "$infile" || die "$progname: Cannot open input file '$infile': $!\n"; $infile =~ s|$root|| if defined($root); my $takeit=0; my $line=0; my $beginline=0; while () { $line++; if (m/ifdef +SIMGRID_TEST/) { $beginline = $line; $takeit = 1; next; } if (m/endif.*SIMGRID_TEST/) { $takeit = 0; next } if (m/XBT_TEST_SUITE\(\w*"([^"]*)"\w*, *(.*?)\);/) { #" { die "$progname: Multiple suites in the same file ($infile) are not supported yet\n" if length($suite_name); ($suite_name,$suite_title)=($1,$2); die "$progname: Empty suite name in $infile" unless length($suite_name); die "$progname: Empty suite title in $infile" unless length($suite_title); next; } elsif (m/XBT_TEST_SUITE/) { die "$progname: Parse error: This line seem to be a test suite declaration, but failed to parse it\n$_\n"; } if (m/XBT_TEST_UNIT\(\w*"([^"]*)"\w*,([^,]*),(.*?)\)/) { #"{ die "$progname: multiply defined unit in file $infile: $1\n" if (defined($tests{$1})); my @t=($1,$2,$3); push @tests,\@t; $tests{$1} = 1; } elsif (m/XBT_TEST_UNIT/) { die "$progname: Parse error: This line seem to be a test unit, but failed to parse it\n$_\n"; } $unit_source .= $_ if $takeit; } close IN || die "$progname: cannot close input file '$infile': $!\n"; if ($takeit) { die "$progname: end of file reached in SIMGRID_TEST block.\n". "You should end each of the with a line matching: /endif.*SIMGRID_TEST/\n". "Example:\n". "#endif /* SIMGRID_TEST */\n" } die "$progname: no suite defined in $infile\n" unless (length($suite_name)); # Write the test my ($GENERATED)=("/*******************************/\n". "/* GENERATED FILE, DO NOT EDIT */\n". "/*******************************/\n\n"); $beginline+=2; open OUT,">$outfile" || die "$progname: Cannot open output file '$outfile': $!\n"; print OUT $GENERATED; print OUT "#include \n"; print OUT "#include \"xbt.h\"\n"; print OUT $GENERATED; print OUT "#line $beginline \"$infile\" \n"; print OUT "$unit_source"; print OUT $GENERATED; close OUT || die "$progname: Cannot close output file '$outfile': $!\n"; # write the main skeleton if needed if (! -e "${outdir}simgrid_units_main.c") { open OUT,">${outdir}simgrid_units_main.c" || die "$progname: Cannot open main file '${outdir}simgrid_units_main.c': $!\n"; print OUT $GENERATED; print OUT "#include \n\n"; print OUT "#include \"xbt.h\"\n\n"; print OUT "extern xbt_test_unit_t _xbt_current_unit;\n\n"; print OUT "/* SGU: BEGIN PROTOTYPES */\n"; print OUT "/* SGU: END PROTOTYPES */\n\n"; print OUT $GENERATED; # print OUT "# 93 \"sg_unit_extractor.pl\"\n"; print OUT <) { $newmain .= $_; # print "Look for proto: $_"; last if /SGU: BEGIN PROTOTYPES/; } # search my prototype while () { # print "Seek protos: $_"; last if (/SGU: END PROTOTYPES/ || /SGU: BEGIN FILE $infile/); $newmain .= $_; } if (/SGU: BEGIN FILE $infile/) { # found an old section for this file. Kill it while () { last if /SGU: END FILE/; } $_ = ; # pass extra blank line chomp; die "this line should be blank ($_). Did you edit the file?" if /\W/; } my ($old_)=($_); # add my section $newmain .= " /* SGU: BEGIN FILE $infile */\n"; map { my ($name,$func,$title) = @{$_}; $newmain .= " void $func(void);\n" } @tests; $newmain .= " /* SGU: END FILE */\n\n"; if ($old_ =~ /SGU: BEGIN FILE/ || $old_ =~ /SGU: END PROTOTYPES/) { $newmain .= $old_; } # pass remaining prototypes, search declarations while () { $newmain .= $_ unless /SGU: END PROTOTYPES/; last if /SGU: BEGIN SUITES DECLARATION/; } ### Done with prototypes. And now, the actual code # search my prototype while () { last if (/SGU: END SUITES DECLARATION/ || /SGU: BEGIN FILE $infile/); $newmain .= $_; } if (/SGU: BEGIN FILE $infile/) { # found an old section for this file. Kill it while () { last if /SGU: END FILE/; } $_ = ; # pass extra blank line chomp; die "this line should be blank ($_). Did you edit the file?" if /\W/; } my ($old_)=($_); # add my section $newmain .= " /* SGU: BEGIN FILE $infile */\n"; $newmain .= " suite = xbt_test_suite_by_name(\"$suite_name\",$suite_title);\n"; map { my ($name,$func,$title) = @{$_}; $newmain .= " xbt_test_suite_push(suite, \"$name\", $func, $title);\n"; } @tests; $newmain .= " /* SGU: END FILE */\n\n"; if ($old_ =~ /SGU: BEGIN FILE/ || $old_ =~ /SGU: END SUITES DECLARATION/) { $newmain .= $old_; } # pass the remaining while () { $newmain .= $_; } close IN || die "$progname: Cannot close main file '${outdir}simgrid_units_main.c': $!\n"; # write it back to main open OUT,">${outdir}simgrid_units_main.c" || die "$progname: Cannot open main file '${outdir}simgrid_units_main.c': $!\n"; print OUT $newmain; close OUT || die "$progname: Cannot close main file '${outdir}simgrid_units_main.c': $!\n"; } # end if process_one($) 0; SimGrid-3.11/tools/doxygen/000755 001750 001750 00000000000 12342443657 014653 5ustar00cici000000 000000 SimGrid-3.11/tools/doxygen/index_create.pl000755 001750 001750 00000003427 12342443657 017653 0ustar00cici000000 000000 #!/usr/bin/perl -w # Copyright (c) 2005, 2012-2014. The SimGrid Team. # All rights reserved. # This program is free software; you can redistribute it and/or modify it # under the terms of the license (GNU LGPL) which comes with this package. ($#ARGV >= 1) or die "Usage: index_create.pl "; my($type) = ""; my($name) = ""; my(%database); $input = $ARGV[0]; $output = $ARGV[1]; open FILE,$input; while($line=) { chomp $line; if($line=~/compound kind=/) { $type = $line; $type =~ s/^[^\"]*\"//; $type =~ s/\".*$//; $line=;chomp $line; } if($line=~/member kind=/) { $type = $line; $type =~ s/^[^\"]*\"//; $type =~ s/\".*$//; $line=;chomp $line; } if($line=~//) { $name = $line; $name =~ s/.*//; $name =~ s/<\/name>.*//; $database{$type}{$name} = 1; $type = ""; $name = ""; next; } } close FILE; open OUTPUT,"> $output"; print OUTPUT <here \\endhtmlonly EOF foreach $type (qw(define enumeration enumvalue function typedef)) { if(defined $database{$type}) { print OUTPUT "

$type

\n
    \n"; foreach $name (sort keys %{$database{$type}}) { if($type eq "function") { print OUTPUT "\t
  • $name()
    • \n"; } else { print OUTPUT "\t
  • #$name
    • \n"; } } print OUTPUT "\n
\n"; } } print OUTPUT "*/"; close OUTPUT; SimGrid-3.11/tools/doxygen/xbt_log_extract_hierarchy.pl000755 001750 001750 00000007345 12342443657 022452 0ustar00cici000000 000000 #!/usr/bin/perl # Copyright (c) 2008, 2010, 2012-2014. The SimGrid Team. # All rights reserved. # This program is free software; you can redistribute it and/or modify it # under the terms of the license (GNU LGPL) which comes with this package. use strict; use warnings; my $debug = 0; print "/* Generated file, do not edit */\n"; print "/** \\addtogroup XBT_log_cats\n"; print " \@{\n"; # Search for calls to macros defining new channels, and prepare the tree representation my %ancestor; my %desc; # $ancestor{"toto"} is the ancestor of the toto channel # as declared by XBT_LOG_NEW_SUBCATEGORY and XBT_LOG_NEW_DEFAULT_SUBCATEGORY # ie, when the channel toto is initialized (does not work under windows) # $desc{"toto"} is its description my %connected; # $connected{"toto"} is defined if XBT_LOG_CONNECT("toto") is used sub cleanup_ctn { my $ctn = shift; # cleanup the content of a macro call $ctn =~ s/^\s*(.*)\s*$/$1/gs; my @elms; print "ctn=$ctn\n" if $debug > 1; if ($ctn =~ m/^(\w+)\s*,\s*(\w+)\s*,\s*"?([^"]*)"?$/s) { # Perfect, we got 0->name; 1->anc; 2->desc $elms[0] = $1; $elms[1] = $2; $elms[2] = $3; } elsif ($ctn =~ m/^(\w+)\s*,\s*"?([^"]*)"?$/s) { # Mmm. got no ancestor. Add the default one. $elms[0] = $1; $elms[1] = "XBT_LOG_ROOT_CAT"; $elms[2] = $2; } else { die "Unparsable content: $ctn\n"; } $elms[2] =~ s/\\\\/\\/gs; return @elms; } sub parse_file { my $filename = shift; my $data = ""; print "Parse $filename\n" if $debug; open IN, "$filename" || die "Cannot read $filename: $!\n"; while () { $data .= $_; } close IN; # Purge $data from C comments $data =~ s|/\*.*?\*/||sg; # C++ comments are forbiden in SG for portability reasons, but deal with it anyway $data =~ s|//.*$||mg; my $connect_data = $data; # save a copy for second parsing phase while ($data =~ s/^.*?XBT_LOG_NEW(_DEFAULT)?_(SUB)?CATEGORY\(//s) { $data =~ s/([^"]*"[^"]*")\)//s || die "unparsable macro: $data"; my ($name,$anc,$desc) = cleanup_ctn($1); # build the tree, checking for name conflict die "ERROR: Category name conflict: $name used several times (in $ancestor{$name} and $anc, last time in $filename)\n" if defined ($ancestor{$name}) && $ancestor{$name} ne $anc && defined ($desc{$name}) && $desc{$name} ne $desc; $ancestor{$name}=$anc; $desc{$name}=$desc; print " $name -> $anc\n" if $debug; } # Now, look for XBT_LOG_CONNECT calls $data = $connect_data; while ($data =~ s/^.*?XBT_LOG_CONNECT\(//s) { $data =~ s/\s*(\w+)\s*\)//s || die "unparsable macro: $data"; $connected{$1} = 1; } } # Retrieve all the file names, and add their content to $data my $data; open FILES, "find ../src/ ../tools/ ../include/ -name '*.c' -o -name '*.cpp' |" || die "Cannot search for the source file names: $!\n"; while (my $file=) { chomp $file; parse_file($file); } close FILES; # Display the tree, looking for disconnected elems my %used; sub display_subtree { my $name=shift; my $indent=shift; $used{$name} = 1; unless ($name eq "XBT_LOG_ROOT_CAT") { # do not display the root print "$indent - $name: ".($desc{$name}|| "(undocumented)")."\n"; } foreach my $cat (grep {$ancestor{$_} eq $name} sort keys %ancestor) { display_subtree($cat,"$indent "); } } display_subtree("XBT_LOG_ROOT_CAT",""); map { warn "Category $_ does not seem to be connected. Use XBT_LOG_CONNECT($_).\n"; } grep {!defined $connected{$_}} sort keys %ancestor; map { warn "Category $_ does not seem to be connected to the root (anc=$ancestor{$_})\n"; } grep {!defined $used{$_}} sort keys %ancestor; print "@}*/\n"; SimGrid-3.11/tools/doxygen/fig2dev_postprocessor.pl000755 001750 001750 00000000776 12342443657 021560 0ustar00cici000000 000000 #! /usr/bin/perl # Copyright (c) 2010, 2014. The SimGrid Team. # All rights reserved. # This program is free software; you can redistribute it and/or modify it # under the terms of the license (GNU LGPL) which comes with this package. use strict; my $print = 0; my $line; while($line=) { chomp $line; if($line=~/IMG/) {$print=1;} if($print) {print $line."\n";} if($line=~/\/MAP/) {$print=0;} } #perl -pe 's/imagemap/simgrid_modules/g'| perl -pe 's/&1 >/dev/null` if [ -n "$err" ] ; then echo "XXXXXXXXXX ERROR IN FILE $file" echo $err fi if [ -n "`eval $cmd 2>/dev/null`" ] ; then echo "XXX FILE $file" eval "$cmd" 2>/dev/null fi done SimGrid-3.11/tools/generate.sh000755 001750 001750 00000000453 12342443657 015331 0ustar00cici000000 000000 #!/bin/sh # Generate files from a given dwarf.h cat "$1" | grep DW_TAG_ | sed 's/.*\(DW_TAG_[^ ]*\) = \(0x[0-9a-f]*\).*/case \2: return "\1";/' > src/mc/mc_dwarf_tagnames.h cat "$1" | grep DW_AT_ | sed 's/.*\(DW_AT_[^ ]*\) = \(0x[0-9a-f]*\).*/case \2: return "\1";/' > src/mc/mc_dwarf_attrnames.h SimGrid-3.11/tools/sg_xml_unit_converter.py000644 001750 001750 00000005633 12342443657 020176 0ustar00cici000000 000000 #!/usr/bin/env python # -*- coding: utf-8 -*- # Copyright (c) 2013-2014. The SimGrid Team. # All rights reserved. # This program is free software; you can redistribute it and/or modify it # under the terms of the license (GNU LGPL) which comes with this package. # grep -ohrI 'bw=".*"' . | sort | uniq import sys, fnmatch, os from decimal import Decimal import re def to_str(dec): return re.sub(r"(\.\d*?)0*$", r"\1", dec.to_eng_string()).rstrip(".") def format(xml, formats, attrib): res = [] m = re.search(r'%s="(.*?)"'%attrib, xml) while m: b, e = m.span(1) res.append(xml[:b]) val = xml[b:e] xml = xml[e:] try: power = Decimal(val) tmp = to_str(power) for p, f in formats: d = power / p if d >= 1.0: tmp = "%s%s"%(to_str(d), f) break res.append(tmp) except: print "Error with:", val res.append(val) m = re.search(r'%s="(.*?)"'%attrib, xml) res.append(xml) return "".join(res) def formats(list): return sorted(((Decimal(i), j) for i,j in list), key=lambda x: x[0], reverse=True) for root, dirnames, filenames in os.walk(sys.argv[1]): for filename in fnmatch.filter(filenames, '*.xml'): print root, dirnames, filename path = os.path.join(root, filename) xml = open(path).read() power_formats = formats([( "1E0", "f"), ( "1E3", "kf"), ( "1E6", "Mf"), ( "1E9", "Gf"), ("1E12", "Tf"), ("1E15", "Pt"), ("1E18", "Ef"), ("1E21", "Zf")]) xml = format(xml, power_formats, "power") bandwidth_formats = formats([( "1E0", "Bps"), ( "1E3", "kBps"), ( "1E6", "MBps"), ( "1E9", "GBps"), ("1E12", "TBps")]) xml = format(xml, bandwidth_formats, "bandwidth") xml = format(xml, bandwidth_formats, "bw") xml = format(xml, bandwidth_formats, "bb_bw") xml = format(xml, bandwidth_formats, "bw_in") xml = format(xml, bandwidth_formats, "bw_out") time_formats = formats([( "1E-12", "ps"), ( "1E-9" , "ns"), ( "1E-6" , "us"), ( "1E-3" , "ms"), ( "1E0" , "s"), ( "60E0" , "m"), ( "3600E0" , "h"), ( "86400E0" , "d"), ("604800E0" , "w")]) xml = format(xml, time_formats, "latency") xml = format(xml, time_formats, "lat") xml = format(xml, time_formats, "bb_lat") #print xml file = open(path, "w") file.write(xml) file.close() SimGrid-3.11/tools/fix-paje-trace.sh000755 001750 001750 00000001446 12342443657 016341 0ustar00cici000000 000000 #!/bin/bash # Copyright (c) 2010, 2014. The SimGrid Team. # All rights reserved. # This program is free software; you can redistribute it and/or modify it # under the terms of the license (GNU LGPL) which comes with this package. if [ -z $1 ] then echo "Usage: $0 {X.trace}" exit fi TRACE=$1 echo "input: $TRACE" OUTPUT=`echo $TRACE | cut -d\. -f1`.fix.trace cat $TRACE | grep ^% > header DEFEVENTS=`cat header | grep Define | awk '{ print $3 }'` GREP="" GREP2="" for i in $DEFEVENTS do GREP="/^$i /d; $GREP" GREP2="-e '^$i ' $GREP2" done GREP="/^%\ /d; /^%E/d; $GREP" cat $TRACE | eval grep $GREP2 > types /bin/sed -e "$GREP" $TRACE > events cat events | sort -n -k 2 -s > events.sorted cat header types events.sorted > $OUTPUT rm types events events.sorted header echo "output: $OUTPUT" SimGrid-3.11/tools/platf_route_rulebased2full.py000755 001750 001750 00000002563 12342443657 021100 0ustar00cici000000 000000 #!/usr/bin/env python # -*- coding: utf-8 -*- # Copyright (c) 2013-2014. The SimGrid Team. # All rights reserved. # This program is free software; you can redistribute it and/or modify it # under the terms of the license (GNU LGPL) which comes with this package. import sys, re from lxml import etree xml = etree.parse(sys.argv[1]) for e in xml.xpath('//*[@routing="RuleBased"]'): e.attrib['routing'] = "Full" ids = e.xpath('./*[@id]/@id') done = set() for asr in e.xpath("./ASroute"): src_ids = {} dst_ids = {} for id in ids: src_s = re.search(r"%s"%asr.attrib['src'], id) dst_s = re.search(r"%s"%asr.attrib['dst'], id) if src_s : src_ids[id] = src_s if dst_s: dst_ids[id] = dst_s for sid, smat in src_ids.items(): for did, dmat in dst_ids.items(): todo = tuple(sorted((smat.group(1), dmat.group(1)))) if todo not in done or asr.attrib.get("symmetrical")=="NO": done.add(todo) dasr = etree.tounicode(asr) dasr = dasr.replace("$1src", smat.group(1)) dasr = dasr.replace("$1dst", dmat.group(1)) dasr = etree.fromstring(dasr) dasr.tag = "__ASroute__" dasr.attrib['src'] = sid dasr.attrib['dst'] = did asr.addnext(dasr) asr.getparent().remove(asr) print etree.tounicode(xml).replace("__ASroute__", "ASroute") SimGrid-3.11/tools/simgrid.supp000644 001750 001750 00000003432 12342443666 015547 0ustar00cici000000 000000 # Valgrind suppressions for stuff that we cannot control # Memory leaks in standard tools (e.g. dash, tail, or sort) { Memory leak in /bin tools Memcheck:Leak ... obj:/bin/* } { Memory leak in /usr/bin tools Memcheck:Leak ... obj:/usr/bin/* } # There's a constant leak of 56 bytes in the depths of libc which # manifests, for example, when using backtrace() { Memory leak in libc/dlopen with -pthread Memcheck:Leak fun:malloc fun:_dl_map_object_deps fun:dl_open_worker fun:_dl_catch_error fun:_dl_open fun:do_dlopen fun:_dl_catch_error fun:dlerror_run fun:__libc_dlopen_mode } # Another problem in glibc, where makecontext does not reset the EBP register, # and backtrace goes too far when walking up the stack frames { Invalid read in backtrace, called after makecontext Memcheck:Addr4 fun:backtrace ... fun:makecontext } # Memory leaks appearing to be in libcgraph. They can be seen with the # following simple program: # ,---- # | #include # | #include # | int main(int argc, char *argv[]) # | { # | if (argc == 1) { # | printf("Usage: %s \n", argv[0]); # | return 1; # | } # | Agraph_t *g; # | FILE *inf = fopen(argv[1], "r"); # | g = agread(inf, 0); # | fclose(inf); # | agclose(g); # | return 0; # | } # `---- { Memory leak in libcgraph (1/2) Memcheck:Leak fun:malloc ... obj:/usr/lib/libcgraph.so* fun:aaglex fun:aagparse fun:agconcat } { Memory leak in libcgraph (2/2) Memcheck:Leak fun:malloc ... fun:agnode obj:/usr/lib/libcgraph.so* fun:aagparse fun:agconcat } # We're not interested by memory leaks in the Lua interpreter { Memory leak in lua Memcheck:Leak ... fun:luaD_precall } SimGrid-3.11/tools/CMakeLists.txt000644 001750 001750 00000001722 12342443654 015735 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(bin_files ${bin_files} ${CMAKE_CURRENT_SOURCE_DIR}/fix-paje-trace.sh ${CMAKE_CURRENT_SOURCE_DIR}/generate.sh ${CMAKE_CURRENT_SOURCE_DIR}/indent ${CMAKE_CURRENT_SOURCE_DIR}/normalize-pointers.py ${CMAKE_CURRENT_SOURCE_DIR}/platf_route_rulebased2full.py ${CMAKE_CURRENT_SOURCE_DIR}/sg_unit_extractor.pl ${CMAKE_CURRENT_SOURCE_DIR}/sg_xml_unit_converter.py ${CMAKE_CURRENT_SOURCE_DIR}/simgrid_update_xml.pl ${CMAKE_CURRENT_SOURCE_DIR}/xbt_exception_checker ${CMAKE_CURRENT_SOURCE_DIR}/doxygen/fig2dev_postprocessor.pl ${CMAKE_CURRENT_SOURCE_DIR}/doxygen/index_create.pl ${CMAKE_CURRENT_SOURCE_DIR}/doxygen/xbt_log_extract_hierarchy.pl ${CMAKE_CURRENT_SOURCE_DIR}/MSG_visualization/colorize.pl ${CMAKE_CURRENT_SOURCE_DIR}/MSG_visualization/trace2fig.pl PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/simgrid.supp ${CMAKE_CURRENT_SOURCE_DIR}/simgrid2vite.sed PARENT_SCOPE ) SimGrid-3.11/include/000755 001750 001750 00000000000 12342443646 013457 5ustar00cici000000 000000 SimGrid-3.11/include/instr/000755 001750 001750 00000000000 12342443646 014616 5ustar00cici000000 000000 SimGrid-3.11/include/instr/jedule/000755 001750 001750 00000000000 12342443653 016064 5ustar00cici000000 000000 SimGrid-3.11/include/instr/jedule/jedule_platform.h000644 001750 001750 00000004465 12342443653 021422 0ustar00cici000000 000000 /* Copyright (c) 2010-2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef JED_SIMGRID_PLATFORM_H_ #define JED_SIMGRID_PLATFORM_H_ #include "simgrid_config.h" #include "xbt/dynar.h" #include "xbt/hash.h" #ifdef HAVE_JEDULE typedef struct jed_simgrid_container s_jed_simgrid_container_t, *jed_simgrid_container_t; struct jed_simgrid_container { char *name; xbt_dynar_t container_children; jed_simgrid_container_t parent; xbt_dynar_t resource_list; xbt_dict_t name2id; int last_id; int is_lowest; }; /** * selection of a subset of resources from the original set * */ struct jed_res_subset { jed_simgrid_container_t parent; int start_idx; // start idx in resource_list of container int nres; // number of resources spanning starting at start_idx }; typedef struct jed_res_subset s_jed_res_subset_t, *jed_res_subset_t; struct jedule_struct { jed_simgrid_container_t root_container; xbt_dict_t jedule_meta_info; }; typedef struct jedule_struct s_jedule_t, *jedule_t; /*********************************************************/ void jed_create_jedule(jedule_t *jedule); void jed_free_jedule(jedule_t jedule); void jedule_add_meta_info(jedule_t jedule, char *key, char *value); void jed_simgrid_create_container(jed_simgrid_container_t *container, const char *name); void jed_simgrid_add_container(jed_simgrid_container_t parent, jed_simgrid_container_t child); void jed_simgrid_add_resources(jed_simgrid_container_t parent, xbt_dynar_t host_names); /** * * it is assumed that the host_names in the entire system are unique * that means that we don't need parent references * * subset_list must be allocated * host_names is the list of host_names associated with an event */ void jed_simgrid_get_resource_selection_by_hosts(xbt_dynar_t subset_list, xbt_dynar_t host_names); /* global: hash host_id -> container container: hash host_id -> jed_host_id list <- [ jed_host_ids ] list <- sort( list ) list_chunks <- chunk( list ) -> [ 1, 3-5, 7-9 ] */ #endif #endif /* JED_SIMGRID_PLATFORM_H_ */ SimGrid-3.11/include/instr/jedule/jedule_sd_binding.h000644 001750 001750 00000001266 12342443653 021672 0ustar00cici000000 000000 /* Copyright (c) 2010-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef JEDULE_SD_BINDING_H_ #define JEDULE_SD_BINDING_H_ #include "simgrid_config.h" #include "simdag/datatypes.h" #include "simdag/simdag.h" #ifdef HAVE_JEDULE void jedule_log_sd_event(SD_task_t task); void jedule_setup_platform(void); void jedule_sd_init(void); void jedule_sd_cleanup(void); void jedule_sd_exit(void); void jedule_sd_dump(void); #endif /* JEDULE_SD_BINDING_H_ */ #endif SimGrid-3.11/include/instr/jedule/jedule_events.h000644 001750 001750 00000002367 12342443653 021101 0ustar00cici000000 000000 /* Copyright (c) 2010-2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef JEDULE_EVENTS_H_ #define JEDULE_EVENTS_H_ #include "simgrid_config.h" #include "xbt/dynar.h" #include "xbt/dict.h" #include "instr/jedule/jedule_platform.h" #ifdef HAVE_JEDULE struct jed_event { int event_id; char *name; double start_time; double end_time; char *type; xbt_dynar_t resource_subsets; xbt_dynar_t characteristics_list; /* just a list of names (strings) */ xbt_dict_t info_hash; /* key/value pairs */ }; typedef struct jed_event s_jed_event_t, *jed_event_t; /************************************************************/ void create_jed_event(jed_event_t *event, char *name, double start_time, double end_time, const char *type); void jed_event_free(jed_event_t event); void jed_event_add_resources(jed_event_t event, xbt_dynar_t host_selection); void jed_event_add_characteristic(jed_event_t event, char *characteristic); void jed_event_add_info(jed_event_t event, char *key, char *value); #endif #endif /* JEDULE_EVENTS_H_ */ SimGrid-3.11/include/instr/jedule/jedule_output.h000644 001750 001750 00000001374 12342443653 021132 0ustar00cici000000 000000 /* Copyright (c) 2010-2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef JEDULE_OUTPUT_H_ #define JEDULE_OUTPUT_H_ #include "simgrid_config.h" #include #include "jedule_events.h" #include "jedule_platform.h" #ifdef HAVE_JEDULE extern xbt_dynar_t jedule_event_list; void jedule_init_output(void); void jedule_cleanup_output(void); void jedule_store_event(jed_event_t event); void write_jedule_output(FILE *file, jedule_t jedule, xbt_dynar_t event_list, xbt_dict_t meta_info_dict); #endif #endif /* JEDULE_OUTPUT_H_ */ SimGrid-3.11/include/instr/instr.h000644 001750 001750 00000017752 12342443646 016142 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef INSTR_H_ #define INSTR_H_ #include "simgrid_config.h" #ifdef HAVE_TRACING #include "xbt.h" #include "xbt/graph.h" #include "msg/msg.h" #include "simdag/simdag.h" /* * Functions to manage tracing categories */ XBT_PUBLIC(void) TRACE_category(const char *category); XBT_PUBLIC(void) TRACE_category_with_color (const char *category, const char *color); XBT_PUBLIC(xbt_dynar_t) TRACE_get_categories (void); XBT_PUBLIC(void) TRACE_smpi_set_category(const char *category); XBT_PUBLIC(void) TRACE_sd_set_task_category(SD_task_t task, const char *category); /* * Functions to manage tracing marks (used for trace comparison experiments) */ XBT_PUBLIC(void) TRACE_declare_mark(const char *mark_type); XBT_PUBLIC(void) TRACE_declare_mark_value_with_color (const char *mark_type, const char *mark_value, const char *mark_color); XBT_PUBLIC(void) TRACE_declare_mark_value (const char *mark_type, const char *mark_value); XBT_PUBLIC(void) TRACE_mark(const char *mark_type, const char *mark_value); XBT_PUBLIC(xbt_dynar_t) TRACE_get_marks (void); /* * Function used by graphicator (transform a SimGrid platform * file in a graphviz dot file with the network topology) */ XBT_PUBLIC(int) TRACE_platform_graph_export_graphviz (const char *filename); /* * User-variables related functions */ /* for VM variables */ XBT_PUBLIC(void) TRACE_vm_variable_declare (const char *variable); XBT_PUBLIC(void) TRACE_vm_variable_declare_with_color (const char *variable, const char *color); XBT_PUBLIC(void) TRACE_vm_variable_set (const char *vm, const char *variable, double value); XBT_PUBLIC(void) TRACE_vm_variable_add (const char *vm, const char *variable, double value); XBT_PUBLIC(void) TRACE_vm_variable_sub (const char *vm, const char *variable, double value); XBT_PUBLIC(void) TRACE_vm_variable_set_with_time (double time, const char *vm, const char *variable, double value); XBT_PUBLIC(void) TRACE_vm_variable_add_with_time (double time, const char *vm, const char *variable, double value); XBT_PUBLIC(void) TRACE_vm_variable_sub_with_time (double time, const char *vm, const char *variable, double value); XBT_PUBLIC(xbt_dynar_t) TRACE_get_vm_variables (void); /* for host variables */ XBT_PUBLIC(void) TRACE_host_variable_declare (const char *variable); XBT_PUBLIC(void) TRACE_host_variable_declare_with_color (const char *variable, const char *color); XBT_PUBLIC(void) TRACE_host_variable_set (const char *host, const char *variable, double value); XBT_PUBLIC(void) TRACE_host_variable_add (const char *host, const char *variable, double value); XBT_PUBLIC(void) TRACE_host_variable_sub (const char *host, const char *variable, double value); XBT_PUBLIC(void) TRACE_host_variable_set_with_time (double time, const char *host, const char *variable, double value); XBT_PUBLIC(void) TRACE_host_variable_add_with_time (double time, const char *host, const char *variable, double value); XBT_PUBLIC(void) TRACE_host_variable_sub_with_time (double time, const char *host, const char *variable, double value); XBT_PUBLIC(xbt_dynar_t) TRACE_get_host_variables (void); /* for link variables */ XBT_PUBLIC(void) TRACE_link_variable_declare (const char *var); XBT_PUBLIC(void) TRACE_link_variable_declare_with_color (const char *var, const char *color); XBT_PUBLIC(void) TRACE_link_variable_set (const char *link, const char *variable, double value); XBT_PUBLIC(void) TRACE_link_variable_add (const char *link, const char *variable, double value); XBT_PUBLIC(void) TRACE_link_variable_sub (const char *link, const char *variable, double value); XBT_PUBLIC(void) TRACE_link_variable_set_with_time (double time, const char *link, const char *variable, double value); XBT_PUBLIC(void) TRACE_link_variable_add_with_time (double time, const char *link, const char *variable, double value); XBT_PUBLIC(void) TRACE_link_variable_sub_with_time (double time, const char *link, const char *variable, double value); /* for link variables, but with src and dst used for get_route */ XBT_PUBLIC(void) TRACE_link_srcdst_variable_set (const char *src, const char *dst, const char *variable, double value); XBT_PUBLIC(void) TRACE_link_srcdst_variable_add (const char *src, const char *dst, const char *variable, double value); XBT_PUBLIC(void) TRACE_link_srcdst_variable_sub (const char *src, const char *dst, const char *variable, double value); XBT_PUBLIC(void) TRACE_link_srcdst_variable_set_with_time (double time, const char *src, const char *dst, const char *variable, double value); XBT_PUBLIC(void) TRACE_link_srcdst_variable_add_with_time (double time, const char *src, const char *dst, const char *variable, double value); XBT_PUBLIC(void) TRACE_link_srcdst_variable_sub_with_time (double time, const char *src, const char *dst, const char *variable, double value); XBT_PUBLIC(xbt_dynar_t) TRACE_get_link_variables (void); XBT_PUBLIC(void) TRACE_host_state_declare (const char *state); XBT_PUBLIC(void) TRACE_host_state_declare_value (const char *state, const char *value, const char *color); XBT_PUBLIC(void) TRACE_host_set_state (const char *host, const char *state, const char *value); XBT_PUBLIC(void) TRACE_host_push_state (const char *host, const char *state, const char *value); XBT_PUBLIC(void) TRACE_host_pop_state (const char *host, const char *state); XBT_PUBLIC(void) TRACE_host_reset_state (const char *host, const char *state); /* for creating graph configuration files for Viva by hand */ XBT_PUBLIC(xbt_dynar_t) TRACE_get_node_types (void); XBT_PUBLIC(xbt_dynar_t) TRACE_get_edge_types (void); XBT_PUBLIC(void) TRACE_pause (void); XBT_PUBLIC(void) TRACE_resume (void); #else /* HAVE_TRACING */ #define TRACE_category(category) #define TRACE_category_with_color(category,color) #define TRACE_get_categories() #define TRACE_smpi_set_category(category) #define TRACE_declare_mark(mark_type) #define TRACE_mark(mark_type,mark_value) #define TRACE_get_marks() #define TRACE_platform_graph_export_graphviz(filename) #define TRACE_vm_variable_declare(var) #define TRACE_vm_variable_declare_with_color(var,color) #define TRACE_vm_variable_set(vm,var,value) #define TRACE_vm_variable_add(vm,var,value) #define TRACE_vm_variable_sub(vm,var,value) #define TRACE_vm_variable_set_with_time(time,vm,var,value) #define TRACE_vm_variable_add_with_time(time,vm,var,value) #define TRACE_vm_variable_sub_with_time(time,vm,var,value) #define TRACE_get_vm_variables() #define TRACE_host_variable_declare(var) #define TRACE_host_variable_declare_with_color(var,color) #define TRACE_host_variable_set(host,var,value) #define TRACE_host_variable_add(host,var,value) #define TRACE_host_variable_sub(host,var,value) #define TRACE_host_variable_set_with_time(time,host,var,value) #define TRACE_host_variable_add_with_time(time,host,var,value) #define TRACE_host_variable_sub_with_time(time,host,var,value) #define TRACE_get_host_variables() #define TRACE_link_variable_declare(var) #define TRACE_link_variable_declare_with_color(var,color) #define TRACE_link_variable_set(link,var,value) #define TRACE_link_variable_add(link,var,value) #define TRACE_link_variable_sub(link,var,value) #define TRACE_link_variable_set_with_time(time,link,var,value) #define TRACE_link_variable_add_with_time(time,link,var,value) #define TRACE_link_variable_sub_with_time(time,link,var,value) #define TRACE_link_srcdst_variable_set(src,dst,var,value) #define TRACE_link_srcdst_variable_add(src,dst,var,value) #define TRACE_link_srcdst_variable_sub(src,dst,var,value) #define TRACE_link_srcdst_variable_set_with_time(time,src,dst,var,value) #define TRACE_link_srcdst_variable_add_with_time(time,src,dst,var,value) #define TRACE_link_srcdst_variable_sub_with_time(time,src,dst,var,value) #define TRACE_get_host_variables() #define TRACE_get_node_types() #define TRACE_get_edge_types() #endif /* HAVE_TRACING */ #endif /* INSTR_H_ */ SimGrid-3.11/include/simgrid_config.h.in000644 001750 001750 00000011373 12342443646 017225 0ustar00cici000000 000000 /* simgrid_config.h - Results of the configure made visible to user code */ /* Copyright (c) 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "xbt/misc.h" /* XBT_PUBLIC */ #include "xbt/dynar.h" /* sg_commandline */ #ifndef SIMGRID_PUBLIC_CONFIG_H #define SIMGRID_PUBLIC_CONFIG_H SG_BEGIN_DECL() /** Define the version numbers of the used header files. sg_version() can be used to retrieve the version of the dynamic library. But actually, if these numbers don't match, SimGrid refuses to start (so you shouldn't have to care about sg_version() yourself) */ #define SIMGRID_VERSION_MAJOR @SIMGRID_VERSION_MAJOR@ #define SIMGRID_VERSION_MINOR @SIMGRID_VERSION_MINOR@ #define SIMGRID_VERSION_PATCH @SIMGRID_VERSION_PATCH@ #define SIMGRID_VERSION_STRING "@SIMGRID_VERSION_STRING@" /* Version X.Y.Z will get version number XYZ: all digits concatenated without dots * (with Y and Z must be on two positions)*/ #define MAKE_SIMGRID_VERSION(major, minor, patch) \ (100UL * (100UL * (major) + (minor)) + (patch)) #define SIMGRID_VERSION MAKE_SIMGRID_VERSION(SIMGRID_VERSION_MAJOR, \ SIMGRID_VERSION_MINOR, \ SIMGRID_VERSION_PATCH) /** Retrieves the version numbers of the used dynamic library (so, DLL or dynlib) , while SIMGRID_VERSION_MAJOR and friends give the version numbers of the used header files */ XBT_PUBLIC(void) sg_version(int *major,int *minor,int *patch); /** Contains all the parameters we got from the command line */ XBT_PUBLIC_DATA(xbt_dynar_t) sg_cmdline; /* take care of DLL usage madness */ #ifdef _XBT_DLL_EXPORT #ifndef DLL_EXPORT #define DLL_EXPORT #endif #else #ifdef _XBT_DLL_STATIC #ifndef DLL_STATIC #define DLL_STATIC #endif #else #ifndef DLL_EXPORT #define DLL_IMPORT #endif #endif #endif #cmakedefine _XBT_WIN32 @_XBT_WIN32@ /*this variable is set if it is a windows platform*/ #cmakedefine _WIN32 @_WIN32@ /*this variable is set if it is a 32 bits windows platform*/ #cmakedefine _WIN64 @_WIN64@ /*this variable is set if it is a 64 bits windows platform*/ #cmakedefine __VISUALC__ @__VISUALC__@ #cmakedefine __BORLANDC__ @__BORLANDC__@ #ifdef _XBT_WIN32 #ifndef __GNUC__ #cmakedefine __GNUC__ @__GNUC__@ #endif #endif /* Define to 1 if mmalloc is compiled in. */ #cmakedefine HAVE_MMALLOC @HAVE_MMALLOC@ /* Get the config */ #undef SIMGRID_NEED_ASPRINTF #undef SIMGRID_NEED_VASPRINTF @simgrid_need_asprintf@ @simgrid_need_vasprintf@ #include /* snprintf related functions */ /** @addtogroup XBT_str * @{ */ /** @brief print to allocated string (reimplemented when not provided by the system) * * The functions asprintf() and vasprintf() are analogues of * sprintf() and vsprintf(), except that they allocate a string large * enough to hold the output including the terminating null byte, and * return a pointer to it via the first parameter. This pointer * should be passed to free(3) to release the allocated storage when * it is no longer needed. */ #if defined(SIMGRID_NEED_ASPRINTF)||defined(DOXYGEN) XBT_PUBLIC(int) asprintf(char **ptr, const char *fmt, /*args */ ...) _XBT_GNUC_PRINTF(2, 3); #endif /** @brief print to allocated string (reimplemented when not provided by the system) * * See asprintf() */ #if defined(SIMGRID_NEED_VASPRINTF)||defined(DOXYGEN) XBT_PUBLIC(int) vasprintf(char **ptr, const char *fmt, va_list ap); #endif /** @brief print to allocated string * * Works just like vasprintf(), but returns a pointer to the newly * created string, or aborts on error. */ XBT_PUBLIC(char *) bvprintf(const char *fmt, va_list ap); /** @brief print to allocated string * * Works just like asprintf(), but returns a pointer to the newly * created string, or aborts on error. */ XBT_PUBLIC(char *) bprintf(const char *fmt, ...) _XBT_GNUC_PRINTF(1, 2); /** @} */ /* Whether mallocators were enabled in ccmake or not. */ #define MALLOCATOR_COMPILED_IN @MALLOCATOR_IS_WANTED@ /* Define if xbt contexts are based on our threads implementation or not */ #cmakedefine CONTEXT_THREADS @CONTEXT_THREADS@ /* Tracing SimGrid */ #cmakedefine HAVE_TRACING @HAVE_TRACING@ /* Jedule output */ #cmakedefine HAVE_JEDULE @HAVE_JEDULE@ /* Tracking of latency bound */ #cmakedefine HAVE_LATENCY_BOUND_TRACKING @HAVE_LATENCY_BOUND_TRACKING@ /* If __thread is available */ #cmakedefine HAVE_THREAD_LOCAL_STORAGE @HAVE_THREAD_LOCAL_STORAGE@ /* If Model-Checking support was requested */ #cmakedefine HAVE_MC @HAVE_MC@ SG_END_DECL() #endif /* SIMGRID_PUBLIC_CONFIG_H */ SimGrid-3.11/include/msg/000755 001750 001750 00000000000 12342443646 014245 5ustar00cici000000 000000 SimGrid-3.11/include/msg/msg.h000644 001750 001750 00000062134 12342443646 015212 0ustar00cici000000 000000 /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef MSG_H #define MSG_H #include "xbt.h" #include "msg/datatypes.h" #include "simgrid/simix.h" #include "simgrid/platf.h" SG_BEGIN_DECL() /** @brief Return code of most MSG functions @ingroup msg_simulation @{ */ /* Keep these code as binary values: java bindings manipulate | of these values */ typedef enum { MSG_OK = 0, /**< @brief Everything is right. Keep on going this way ! */ MSG_TIMEOUT = 1, /**< @brief nothing good happened before the timer you provided elapsed */ MSG_TRANSFER_FAILURE = 2, /**< @brief There has been a problem during you task transfer. Either the network is down or the remote host has been shutdown. */ MSG_HOST_FAILURE = 4, /**< @brief System shutdown. The host on which you are running has just been rebooted. Free your datastructures and return now !*/ MSG_TASK_CANCELED = 8 /**< @brief Canceled task. This task has been canceled by somebody!*/ } msg_error_t; /** @} */ /************************** Global ******************************************/ XBT_PUBLIC(void) MSG_config(const char *key, const char *value); /** \ingroup msg_simulation * \brief Initialize the MSG internal data. * \hideinitializer * * It also check that the link-time and compile-time versions of SimGrid do * match, so you should use this version instead of the #MSG_init_nocheck * function that does the same initializations, but without this check. * * We allow to link against compiled versions that differ in the patch level. */ #define MSG_init(argc,argv) { \ int ver_major,ver_minor,ver_patch; \ sg_version(&ver_major,&ver_minor,&ver_patch); \ if ((ver_major != SIMGRID_VERSION_MAJOR) || \ (ver_minor != SIMGRID_VERSION_MINOR)) { \ fprintf(stderr,"FATAL ERROR: Your program was compiled with SimGrid version %d.%d.%d, and then linked against SimGrid %d.%d.%d. Please fix this.\n", \ SIMGRID_VERSION_MAJOR,SIMGRID_VERSION_MINOR,SIMGRID_VERSION_PATCH,ver_major,ver_minor,ver_patch); \ } \ MSG_init_nocheck(argc,argv); \ } XBT_PUBLIC(void) MSG_init_nocheck(int *argc, char **argv); XBT_PUBLIC(msg_error_t) MSG_main(void); XBT_PUBLIC(void) MSG_function_register(const char *name, xbt_main_func_t code); XBT_PUBLIC(void) MSG_function_register_default(xbt_main_func_t code); XBT_PUBLIC(xbt_main_func_t) MSG_get_registered_function(const char *name); XBT_PUBLIC(void) MSG_launch_application(const char *file); /*Bypass the parser */ XBT_PUBLIC(void) MSG_set_function(const char *host_id, const char *function_name, xbt_dynar_t arguments); XBT_PUBLIC(double) MSG_get_clock(void); XBT_PUBLIC(unsigned long int) MSG_get_sent_msg(void); /************************** Environment ***********************************/ XBT_PUBLIC(msg_as_t) MSG_environment_get_routing_root(void); XBT_PUBLIC(const char *) MSG_environment_as_get_name(msg_as_t as); XBT_PUBLIC(msg_as_t) MSG_environment_as_get_by_name(const char * name); XBT_PUBLIC(xbt_dict_t) MSG_environment_as_get_routing_sons(msg_as_t as); XBT_PUBLIC(const char *) MSG_environment_as_get_property_value(msg_as_t as, const char *name); XBT_PUBLIC(const char *) MSG_environment_as_get_model(msg_as_t as); XBT_PUBLIC(xbt_dynar_t) MSG_environment_as_get_hosts(msg_as_t as); /************************** File handling ***********************************/ XBT_PUBLIC(sg_size_t) MSG_file_read(msg_file_t fd, sg_size_t size); XBT_PUBLIC(sg_size_t) MSG_file_write(msg_file_t fd, sg_size_t size); XBT_PUBLIC(msg_file_t) MSG_file_open(const char* fullpath, void* data); XBT_PUBLIC(void*) MSG_file_get_data(msg_file_t fd); XBT_PUBLIC(msg_error_t) MSG_file_set_data(msg_file_t fd, void * data); XBT_PUBLIC(int) MSG_file_close(msg_file_t fd); XBT_PUBLIC(sg_size_t) MSG_file_get_size(msg_file_t fd); XBT_PUBLIC(void) MSG_file_dump(msg_file_t fd); XBT_PUBLIC(msg_error_t) MSG_file_unlink(msg_file_t fd); XBT_PUBLIC(msg_error_t) MSG_file_seek(msg_file_t fd, sg_offset_t offset, int origin); XBT_PUBLIC(sg_size_t) MSG_file_tell (msg_file_t fd); XBT_PUBLIC(void) __MSG_file_get_info(msg_file_t fd); XBT_PUBLIC(void) __MSG_file_priv_free(msg_file_priv_t priv); XBT_PUBLIC(const char *) MSG_file_get_name(msg_file_t storage); XBT_PUBLIC(msg_error_t) MSG_file_move(msg_file_t fd, const char* fullpath); XBT_PUBLIC(msg_error_t) MSG_file_rcopy(msg_file_t fd, msg_host_t host, const char* fullpath); XBT_PUBLIC(msg_error_t) MSG_file_rmove(msg_file_t fd, msg_host_t host, const char* fullpath); /************************** Storage handling ***********************************/ XBT_PUBLIC(msg_host_t) MSG_get_storage_by_name(const char *name); XBT_PUBLIC(const char *) MSG_storage_get_name(msg_storage_t storage); XBT_PUBLIC(sg_size_t) MSG_storage_get_free_size(msg_storage_t storage); XBT_PUBLIC(sg_size_t) MSG_storage_get_used_size(msg_storage_t storage); XBT_PUBLIC(msg_storage_t) MSG_storage_get_by_name(const char *name); XBT_PUBLIC(xbt_dict_t) MSG_storage_get_properties(msg_storage_t storage); XBT_PUBLIC(void) MSG_storage_set_property_value(msg_storage_t storage, const char *name, char *value,void_f_pvoid_t free_ctn); XBT_PUBLIC(xbt_dynar_t) MSG_storages_as_dynar(void); XBT_PUBLIC(msg_error_t) MSG_storage_set_data(msg_storage_t host, void *data); XBT_PUBLIC(void *) MSG_storage_get_data(msg_storage_t storage); XBT_PUBLIC(xbt_dict_t) MSG_storage_get_content(msg_storage_t storage); XBT_PUBLIC(sg_size_t) MSG_storage_get_size(msg_storage_t storage); XBT_PUBLIC(msg_error_t) MSG_storage_file_move(msg_file_t fd, msg_host_t dest, char* mount, char* fullname); XBT_PUBLIC(const char *) MSG_storage_get_host(msg_storage_t storage); /************************** AS Router handling ************************************/ XBT_PUBLIC(const char *) MSG_as_router_get_property_value(const char* asr, const char *name); XBT_PUBLIC(xbt_dict_t) MSG_as_router_get_properties(const char* asr); XBT_PUBLIC(void) MSG_as_router_set_property_value(const char* asr, const char *name, char *value,void_f_pvoid_t free_ctn); /************************** Host handling ***********************************/ XBT_PUBLIC(msg_error_t) MSG_host_set_data(msg_host_t host, void *data); XBT_PUBLIC(void *) MSG_host_get_data(msg_host_t host); XBT_PUBLIC(const char *) MSG_host_get_name(msg_host_t host); XBT_PUBLIC(void) MSG_host_on(msg_host_t host); XBT_PUBLIC(void) MSG_host_off(msg_host_t host); XBT_PUBLIC(msg_host_t) MSG_host_self(void); XBT_PUBLIC(int) MSG_get_host_msgload(msg_host_t host); XBT_PUBLIC(double) MSG_get_host_speed(msg_host_t h); XBT_PUBLIC(int) MSG_host_get_core_number(msg_host_t h); XBT_PUBLIC(xbt_swag_t) MSG_host_get_process_list(msg_host_t h); XBT_PUBLIC(int) MSG_host_is_avail(msg_host_t h); XBT_PUBLIC(void) __MSG_host_priv_free(msg_host_priv_t priv); XBT_PUBLIC(void) __MSG_host_destroy(msg_host_t host); XBT_PUBLIC(double) MSG_get_host_power_peak_at(msg_host_t h, int pstate_index); XBT_PUBLIC(double) MSG_get_host_current_power_peak(msg_host_t h); XBT_PUBLIC(int) MSG_get_host_nb_pstates(msg_host_t h); XBT_PUBLIC(void) MSG_set_host_power_peak_at(msg_host_t h, int pstate); XBT_PUBLIC(double) MSG_get_host_consumed_energy(msg_host_t h); /*property handlers*/ XBT_PUBLIC(xbt_dict_t) MSG_host_get_properties(msg_host_t host); XBT_PUBLIC(const char *) MSG_host_get_property_value(msg_host_t host, const char *name); XBT_PUBLIC(void) MSG_host_set_property_value(msg_host_t host, const char *name, char *value, void_f_pvoid_t free_ctn); XBT_PUBLIC(void) MSG_create_environment(const char *file); XBT_PUBLIC(msg_host_t) MSG_get_host_by_name(const char *name); XBT_PUBLIC(xbt_dynar_t) MSG_hosts_as_dynar(void); XBT_PUBLIC(int) MSG_get_host_number(void); XBT_PUBLIC(void) MSG_host_get_params(msg_host_t ind_pm, ws_params_t params); XBT_PUBLIC(void) MSG_host_set_params(msg_host_t ind_pm, ws_params_t params); XBT_PUBLIC(xbt_dict_t) MSG_host_get_mounted_storage_list(msg_host_t host); XBT_PUBLIC(xbt_dynar_t) MSG_host_get_attached_storage_list(msg_host_t host); XBT_PUBLIC(xbt_dict_t) MSG_host_get_storage_content(msg_host_t host); /************************** Process handling *********************************/ XBT_PUBLIC(msg_process_t) MSG_process_create(const char *name, xbt_main_func_t code, void *data, msg_host_t host); XBT_PUBLIC(msg_process_t) MSG_process_create_with_arguments(const char *name, xbt_main_func_t code, void *data, msg_host_t host, int argc, char **argv); XBT_PUBLIC(msg_process_t) MSG_process_create_with_environment(const char *name, xbt_main_func_t code, void *data, msg_host_t host, int argc, char **argv, xbt_dict_t properties); XBT_PUBLIC(void) MSG_process_kill(msg_process_t process); XBT_PUBLIC(int) MSG_process_killall(int reset_PIDs); XBT_PUBLIC(msg_error_t) MSG_process_migrate(msg_process_t process, msg_host_t host); XBT_PUBLIC(void *) MSG_process_get_data(msg_process_t process); XBT_PUBLIC(msg_error_t) MSG_process_set_data(msg_process_t process, void *data); XBT_PUBLIC(void) MSG_process_set_data_cleanup(void_f_pvoid_t data_cleanup); XBT_PUBLIC(msg_host_t) MSG_process_get_host(msg_process_t process); XBT_PUBLIC(msg_process_t) MSG_process_from_PID(int PID); XBT_PUBLIC(int) MSG_process_get_PID(msg_process_t process); XBT_PUBLIC(int) MSG_process_get_PPID(msg_process_t process); XBT_PUBLIC(const char *) MSG_process_get_name(msg_process_t process); XBT_PUBLIC(int) MSG_process_self_PID(void); XBT_PUBLIC(int) MSG_process_self_PPID(void); XBT_PUBLIC(msg_process_t) MSG_process_self(void); XBT_PUBLIC(xbt_dynar_t) MSG_processes_as_dynar(void); XBT_PUBLIC(int) MSG_process_get_number(void); XBT_PUBLIC(msg_error_t) MSG_process_set_kill_time(msg_process_t process, double kill_time); /*property handlers*/ XBT_PUBLIC(xbt_dict_t) MSG_process_get_properties(msg_process_t process); XBT_PUBLIC(const char *) MSG_process_get_property_value(msg_process_t process, const char *name); XBT_PUBLIC(msg_error_t) MSG_process_suspend(msg_process_t process); XBT_PUBLIC(msg_error_t) MSG_process_resume(msg_process_t process); XBT_PUBLIC(int) MSG_process_is_suspended(msg_process_t process); XBT_PUBLIC(void) MSG_process_on_exit(int_f_pvoid_pvoid_t fun, void *data); XBT_PUBLIC(void) MSG_process_auto_restart_set(msg_process_t process, int auto_restart); XBT_PUBLIC(msg_process_t) MSG_process_restart(msg_process_t process); /************************** Task handling ************************************/ XBT_PUBLIC(msg_task_t) MSG_task_create(const char *name, double compute_duration, double message_size, void *data); XBT_PUBLIC(msg_gpu_task_t) MSG_gpu_task_create(const char *name, double compute_duration, double dispatch_latency, double collect_latency); XBT_PUBLIC(msg_task_t) MSG_parallel_task_create(const char *name, int host_nb, const msg_host_t * host_list, double *computation_amount, double *communication_amount, void *data); XBT_PUBLIC(void *) MSG_task_get_data(msg_task_t task); XBT_PUBLIC(void) MSG_task_set_data(msg_task_t task, void *data); XBT_PUBLIC(void) MSG_task_set_copy_callback(void (*callback) ( msg_task_t task, msg_process_t src, msg_process_t dst)); XBT_PUBLIC(msg_process_t) MSG_task_get_sender(msg_task_t task); XBT_PUBLIC(msg_host_t) MSG_task_get_source(msg_task_t task); XBT_PUBLIC(const char *) MSG_task_get_name(msg_task_t task); XBT_PUBLIC(void) MSG_task_set_name(msg_task_t task, const char *name); XBT_PUBLIC(msg_error_t) MSG_task_cancel(msg_task_t task); XBT_PUBLIC(msg_error_t) MSG_task_destroy(msg_task_t task); XBT_PUBLIC(msg_error_t) MSG_task_receive_from_host(msg_task_t * task, const char *alias, msg_host_t host); XBT_PUBLIC(msg_error_t) MSG_task_receive_from_host_bounded(msg_task_t * task, const char *alias, msg_host_t host, double rate); XBT_PUBLIC(msg_error_t) MSG_task_execute(msg_task_t task); XBT_PUBLIC(msg_error_t) MSG_parallel_task_execute(msg_task_t task); XBT_PUBLIC(void) MSG_task_set_priority(msg_task_t task, double priority); XBT_PUBLIC(void) MSG_task_set_bound(msg_task_t task, double bound); XBT_PUBLIC(void) MSG_task_set_affinity(msg_task_t task, msg_host_t host, unsigned long mask); XBT_PUBLIC(msg_error_t) MSG_process_join(msg_process_t process, double timeout); XBT_PUBLIC(msg_error_t) MSG_process_sleep(double nb_sec); XBT_PUBLIC(double) MSG_task_get_compute_duration(msg_task_t task); XBT_PUBLIC(void) MSG_task_set_compute_duration(msg_task_t task, double compute_duration); XBT_PUBLIC(void) MSG_task_set_data_size(msg_task_t task, double data_size); XBT_PUBLIC(double) MSG_task_get_remaining_computation(msg_task_t task); XBT_PUBLIC(double) MSG_task_get_remaining_communication(msg_task_t task); XBT_PUBLIC(int) MSG_task_is_latency_bounded(msg_task_t task); XBT_PUBLIC(double) MSG_task_get_data_size(msg_task_t task); XBT_PUBLIC(msg_error_t) MSG_task_receive_ext(msg_task_t * task, const char *alias, double timeout, msg_host_t host); XBT_PUBLIC(msg_error_t) MSG_task_receive_with_timeout(msg_task_t * task, const char *alias, double timeout); XBT_PUBLIC(msg_error_t) MSG_task_receive(msg_task_t * task, const char *alias); #define MSG_task_recv(t,a) MSG_task_receive(t,a) XBT_PUBLIC(msg_error_t) MSG_task_receive_ext_bounded(msg_task_t * task, const char *alias, double timeout, msg_host_t host, double rate); XBT_PUBLIC(msg_error_t) MSG_task_receive_with_timeout_bounded(msg_task_t * task, const char *alias, double timeout, double rate); XBT_PUBLIC(msg_error_t) MSG_task_receive_bounded(msg_task_t * task, const char *alias,double rate); #define MSG_task_recv_bounded(t,a,r) MSG_task_receive_bounded(t,a,r) XBT_PUBLIC(msg_comm_t) MSG_task_isend(msg_task_t task, const char *alias); XBT_PUBLIC(msg_comm_t) MSG_task_isend_bounded(msg_task_t task, const char *alias, double maxrate); XBT_PUBLIC(msg_comm_t) MSG_task_isend_with_matching(msg_task_t task, const char *alias, int (*match_fun)(void*,void*, smx_action_t), void *match_data); XBT_PUBLIC(void) MSG_task_dsend(msg_task_t task, const char *alias, void_f_pvoid_t cleanup); XBT_PUBLIC(void) MSG_task_dsend_bounded(msg_task_t task, const char *alias, void_f_pvoid_t cleanup, double maxrate); XBT_PUBLIC(msg_comm_t) MSG_task_irecv(msg_task_t * task, const char *alias); XBT_PUBLIC(msg_comm_t) MSG_task_irecv_bounded(msg_task_t * task, const char *alias, double rate); XBT_PUBLIC(int) MSG_comm_test(msg_comm_t comm); XBT_PUBLIC(int) MSG_comm_testany(xbt_dynar_t comms); XBT_PUBLIC(void) MSG_comm_destroy(msg_comm_t comm); XBT_PUBLIC(msg_error_t) MSG_comm_wait(msg_comm_t comm, double timeout); XBT_PUBLIC(void) MSG_comm_waitall(msg_comm_t * comm, int nb_elem, double timeout); XBT_PUBLIC(int) MSG_comm_waitany(xbt_dynar_t comms); XBT_PUBLIC(msg_task_t) MSG_comm_get_task(msg_comm_t comm); XBT_PUBLIC(msg_error_t) MSG_comm_get_status(msg_comm_t comm); XBT_PUBLIC(int) MSG_task_listen(const char *alias); XBT_PUBLIC(int) MSG_task_listen_from_host(const char *alias, msg_host_t host); XBT_PUBLIC(msg_error_t) MSG_task_send_with_timeout(msg_task_t task, const char *alias, double timeout); XBT_PUBLIC(msg_error_t) MSG_task_send_with_timeout_bounded(msg_task_t task, const char *alias, double timeout, double maxrate); XBT_PUBLIC(msg_error_t) MSG_task_send(msg_task_t task, const char *alias); XBT_PUBLIC(msg_error_t) MSG_task_send_bounded(msg_task_t task, const char *alias, double rate); XBT_PUBLIC(int) MSG_task_listen_from(const char *alias); XBT_PUBLIC(void) MSG_task_set_category (msg_task_t task, const char *category); XBT_PUBLIC(const char *) MSG_task_get_category (msg_task_t task); /************************** Task handling ************************************/ XBT_PUBLIC(msg_error_t) MSG_mailbox_get_task_ext(msg_mailbox_t mailbox, msg_task_t * task, msg_host_t host, double timeout); XBT_PUBLIC(msg_error_t) MSG_mailbox_get_task_ext_bounded(msg_mailbox_t mailbox, msg_task_t *task, msg_host_t host, double timeout, double rate); XBT_PUBLIC(msg_error_t) MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, msg_task_t task, double timeout); XBT_PUBLIC(void) MSG_mailbox_set_async(const char *alias); /************************** Action handling **********************************/ XBT_PUBLIC(msg_error_t) MSG_action_trace_run(char *path); XBT_PUBLIC(void) MSG_action_init(void); XBT_PUBLIC(void) MSG_action_exit(void); #ifdef MSG_USE_DEPRECATED typedef msg_error_t MSG_error_t; #define MSG_global_init(argc, argv) MSG_init(argc,argv) #define MSG_global_init_args(argc, argv) MSG_init(argc,argv) /* these are the functions which are deprecated. Do not use them, they may get removed in future releases */ XBT_PUBLIC(msg_host_t *) MSG_get_host_table(void); #define MSG_TIMEOUT_FAILURE MSG_TIMEOUT #define MSG_TASK_CANCELLED MSG_TASK_CANCELED #define MSG_mailbox_put_with_time_out(mailbox, task, timeout) \ MSG_mailbox_put_with_timeout(mailbox, task, timeout) #define MSG_process_change_host(h) MSG_process_migrate(MSG_process_self(),h); XBT_PUBLIC(msg_error_t) MSG_get_errno(void); XBT_PUBLIC(msg_error_t) MSG_clean(void); XBT_PUBLIC(msg_error_t) MSG_task_get(msg_task_t * task, m_channel_t channel); XBT_PUBLIC(msg_error_t) MSG_task_get_with_timeout(msg_task_t * task, m_channel_t channel, double max_duration); XBT_PUBLIC(msg_error_t) MSG_task_get_from_host(msg_task_t * task, int channel, msg_host_t host); XBT_PUBLIC(msg_error_t) MSG_task_get_ext(msg_task_t * task, int channel, double max_duration, msg_host_t host); XBT_PUBLIC(msg_error_t) MSG_task_put(msg_task_t task, msg_host_t dest, m_channel_t channel); XBT_PUBLIC(msg_error_t) MSG_task_put_bounded(msg_task_t task, msg_host_t dest, m_channel_t channel, double max_rate); XBT_PUBLIC(msg_error_t) MSG_task_put_with_timeout(msg_task_t task, msg_host_t dest, m_channel_t channel, double max_duration); XBT_PUBLIC(int) MSG_task_Iprobe(m_channel_t channel); XBT_PUBLIC(int) MSG_task_probe_from(m_channel_t channel); XBT_PUBLIC(int) MSG_task_probe_from_host(int channel, msg_host_t host); XBT_PUBLIC(msg_error_t) MSG_set_channel_number(int number); XBT_PUBLIC(int) MSG_get_channel_number(void); #endif /** @brief Opaque type representing a semaphore * @ingroup msg_synchro * @hideinitializer */ typedef struct s_smx_sem *msg_sem_t; // Yeah that's a rename of the smx_sem_t which doesnt require smx_sem_t to be declared here XBT_PUBLIC(msg_sem_t) MSG_sem_init(int initial_value); XBT_PUBLIC(void) MSG_sem_acquire(msg_sem_t sem); XBT_PUBLIC(msg_error_t) MSG_sem_acquire_timeout(msg_sem_t sem, double timeout); XBT_PUBLIC(void) MSG_sem_release(msg_sem_t sem); XBT_PUBLIC(void) MSG_sem_get_capacity(msg_sem_t sem); XBT_PUBLIC(void) MSG_sem_destroy(msg_sem_t sem); XBT_PUBLIC(int) MSG_sem_would_block(msg_sem_t sem); /** @brief Opaque type representing a barrier identifier * @ingroup msg_synchro * @hideinitializer */ #define MSG_BARRIER_SERIAL_PROCESS -1 typedef struct s_xbt_bar *msg_bar_t; XBT_PUBLIC(msg_bar_t) MSG_barrier_init( unsigned int count); XBT_PUBLIC(void) MSG_barrier_destroy(msg_bar_t bar); XBT_PUBLIC(int) MSG_barrier_wait(msg_bar_t bar); /** @brief Opaque type describing a Virtual Machine. * @ingroup msg_VMs * * All this is highly experimental and the interface will probably change in the future. * Please don't depend on this yet (although testing is welcomed if you feel so). * Usual lack of guaranty of any kind applies here, and is even increased. * */ XBT_PUBLIC(int) MSG_vm_is_created(msg_vm_t); XBT_PUBLIC(int) MSG_vm_is_running(msg_vm_t); XBT_PUBLIC(int) MSG_vm_is_migrating(msg_vm_t); XBT_PUBLIC(int) MSG_vm_is_suspended(msg_vm_t); XBT_PUBLIC(int) MSG_vm_is_saving(msg_vm_t); XBT_PUBLIC(int) MSG_vm_is_saved(msg_vm_t); XBT_PUBLIC(int) MSG_vm_is_restoring(msg_vm_t); XBT_PUBLIC(const char*) MSG_vm_get_name(msg_vm_t); // TODO add VDI later XBT_PUBLIC(msg_vm_t) MSG_vm_create_core(msg_host_t location, const char *name); XBT_PUBLIC(msg_vm_t) MSG_vm_create(msg_host_t ind_pm, const char *name, int core_nb, int mem_cap, int net_cap, char *disk_path, int disk_size, int mig_netspeed, int dp_intensity); XBT_PUBLIC(void) MSG_vm_destroy(msg_vm_t vm); XBT_PUBLIC(void) MSG_vm_start(msg_vm_t); /* Shutdown the guest operating system. */ XBT_PUBLIC(void) MSG_vm_shutdown(msg_vm_t vm); XBT_PUBLIC(void) MSG_vm_migrate(msg_vm_t vm, msg_host_t destination); /* Suspend the execution of the VM, but keep its state on memory. */ XBT_PUBLIC(void) MSG_vm_suspend(msg_vm_t vm); XBT_PUBLIC(void) MSG_vm_resume(msg_vm_t vm); /* Save the VM state to a disk. */ XBT_PUBLIC(void) MSG_vm_save(msg_vm_t vm); XBT_PUBLIC(void) MSG_vm_restore(msg_vm_t vm); XBT_PUBLIC(msg_host_t) MSG_vm_get_pm(msg_vm_t vm); XBT_PUBLIC(void) MSG_vm_set_bound(msg_vm_t vm, double bound); XBT_PUBLIC(void) MSG_vm_set_affinity(msg_vm_t vm, msg_host_t pm, unsigned long mask); /* TODO: do we need this? */ // XBT_PUBLIC(xbt_dynar_t) MSG_vms_as_dynar(void); /* void* MSG_process_get_property(msg_process_t, char* key) void MSG_process_set_property(msg_process_t, char* key, void* data) void MSG_vm_set_property(msg_vm_t, char* key, void* data) void MSG_vm_setMemoryUsed(msg_vm_t vm, double size); void MSG_vm_setCpuUsed(msg_vm_t vm, double inducedLoad); // inducedLoad: un pourcentage (>100 si ca charge plus d'un coeur; // <100 si c'est pas CPU intensive) // Contraintes à poser: // HOST_Power >= CpuUsedVm (\forall VM) + CpuUsedTask (\forall Task) // VM_coreAmount >= Load de toutes les tasks */ /* xbt_dynar_t MSG_vm_get_list_from_host(msg_host_t) xbt_dynar_t MSG_vm_get_list_from_hosts(msg_dynar_t) + des fonctions de filtrage sur les dynar */ #include "instr/instr.h" /* ****************************************************************************************** */ /* Used only by the bindings -- unclean pimple, please ignore if you're not writing a binding */ XBT_PUBLIC(smx_context_t) MSG_process_get_smx_ctx(msg_process_t process); /* ****************************************************************************************** */ /* TUTORIAL: New API */ /* Declare all functions for the API */ /* ****************************************************************************************** */ XBT_PUBLIC(int) MSG_new_API_fct(const char* param1, double param2); SG_END_DECL() #endif SimGrid-3.11/include/msg/datatypes.h000644 001750 001750 00000015032 12342443646 016415 0ustar00cici000000 000000 /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef MSG_DATATYPE_H #define MSG_DATATYPE_H #include "xbt/misc.h" #include "xbt/lib.h" #include "simgrid/simix.h" #include "simgrid_config.h" // for HAVE_TRACING SG_BEGIN_DECL() /* ******************************** Mailbox ************************************ */ /** @brief Mailbox datatype * @ingroup msg_task_usage * * Object representing a communication rendez-vous point, on which * the sender finds the receiver it wants to communicate with. As a * MSG user, you will only rarely manipulate any of these objects * directly, since most of the public interface (such as * #MSG_task_send and friends) hide this object behind a string * alias. That mean that you don't provide the mailbox on which you * want to send your task, but only the name of this mailbox. */ typedef struct s_smx_rvpoint *msg_mailbox_t; /* ******************************** Environment ************************************ */ typedef struct As *msg_as_t; /* ******************************** Host ************************************ */ extern int MSG_HOST_LEVEL; /** @brief Host datatype. @ingroup m_host_management A location (or host) is any possible place where a process may run. Thus it is represented as a physical resource with computing capabilities, some mailboxes to enable running process to communicate with remote ones, and some private data that can be only accessed by local process. */ typedef xbt_dictelm_t msg_host_t; typedef s_xbt_dictelm_t s_msg_host_t; typedef struct msg_host_priv { int dp_enabled; xbt_dict_t dp_objs; double dp_updated_by_deleted_tasks; xbt_dict_t affinity_mask_db; #ifdef MSG_USE_DEPRECATED msg_mailbox_t *mailboxes; /**< the channels */ #endif } s_msg_host_priv_t, *msg_host_priv_t; static inline msg_host_priv_t MSG_host_priv(msg_host_t host){ return (msg_host_priv_t )xbt_lib_get_level(host, MSG_HOST_LEVEL); } /* ******************************** Task ************************************ */ typedef struct simdata_task *simdata_task_t; typedef struct msg_task { char *name; /**< @brief task name if any */ simdata_task_t simdata; /**< @brief simulator data */ void *data; /**< @brief user data */ #ifdef HAVE_TRACING long long int counter; /* task unique identifier for instrumentation */ char *category; /* task category for instrumentation */ #endif } s_msg_task_t; /** @brief Task datatype. @ingroup m_task_management A task may then be defined by a computing amount, a message size and some private data. */ typedef struct msg_task *msg_task_t; /* ******************************** VM ************************************* */ typedef msg_host_t msg_vm_t; typedef msg_host_priv_t msg_vm_priv_t; static inline msg_vm_priv_t MSG_vm_priv(msg_vm_t vm){ return (msg_vm_priv_t) xbt_lib_get_level(vm, MSG_HOST_LEVEL); } /** ******************************** File ************************************ */ /** @brief File datatype. * @ingroup msg_file_management * * You should consider this as an opaque object. */ typedef xbt_dictelm_t msg_file_t; typedef s_xbt_dictelm_t s_msg_file_t; extern int MSG_FILE_LEVEL; typedef struct simdata_file *simdata_file_t; typedef struct msg_file_priv { char *fullpath; sg_size_t size; char* mount_point; char* storageId; char* storage_type; char* content_type; void *data; simdata_file_t simdata; } s_msg_file_priv_t, *msg_file_priv_t; static inline msg_file_priv_t MSG_file_priv(msg_file_t file){ return (msg_file_priv_t )xbt_lib_get_level(file, MSG_FILE_LEVEL); } /* ******************************** Storage ************************************ */ /* TODO: PV: to comment */ extern int MSG_STORAGE_LEVEL; /** @brief Storage datatype. * @ingroup msg_storage_management * * You should consider this as an opaque object. */ typedef xbt_dictelm_t msg_storage_t; typedef s_xbt_dictelm_t s_msg_storage_t; typedef struct msg_storage_priv { const char *hostname; void *data; } s_msg_storage_priv_t, *msg_storage_priv_t; static inline msg_storage_priv_t MSG_storage_priv(msg_storage_t storage){ return (msg_storage_priv_t )xbt_lib_get_level(storage, MSG_STORAGE_LEVEL); } /*************** Begin GPU ***************/ typedef struct simdata_gpu_task *simdata_gpu_task_t; typedef struct msg_gpu_task { char *name; /**< @brief task name if any */ simdata_gpu_task_t simdata; /**< @brief simulator data */ #ifdef HAVE_TRACING long long int counter; /* task unique identifier for instrumentation */ char *category; /* task category for instrumentation */ #endif } s_msg_gpu_task_t; /** @brief GPU task datatype. @ingroup m_task_management A task may then be defined by a computing amount, a dispatch latency and a collect latency. \see m_task_management */ typedef struct msg_gpu_task *msg_gpu_task_t; /*************** End GPU ***************/ /** * \brief @brief Communication action. * \ingroup msg_task_usage * * Object representing an ongoing communication between processes. Such beast is usually obtained by using #MSG_task_isend, #MSG_task_irecv or friends. */ typedef struct msg_comm *msg_comm_t; /** \brief Default value for an uninitialized #msg_task_t. \ingroup m_task_management */ #define MSG_TASK_UNINITIALIZED NULL /* ****************************** Process *********************************** */ /** @brief Process datatype. @ingroup m_process_management A process may be defined as a code, with some private data, executing in a location. You should not access directly to the fields of the pointed structure, but always use the provided API to interact with processes. */ typedef struct s_smx_process *msg_process_t; #ifdef MSG_USE_DEPRECATED /* Compatibility typedefs */ typedef int m_channel_t; typedef msg_gpu_task_t m_gpu_task_t; typedef msg_host_t m_host_t; typedef msg_process_t m_process_t; typedef msg_task_t m_task_t; typedef s_msg_gpu_task_t s_m_gpu_task_t; typedef s_msg_host_t s_m_host_t; typedef s_msg_task_t s_m_task_t; #endif SG_END_DECL() #endif SimGrid-3.11/include/xbt/000755 001750 001750 00000000000 12342443646 014254 5ustar00cici000000 000000 SimGrid-3.11/include/xbt/automaton.h000644 001750 001750 00000010515 12342443646 016436 0ustar00cici000000 000000 /* Copyright (c) 2011-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_AUTOMATON_H #define _XBT_AUTOMATON_H #include #include #include #include #include SG_BEGIN_DECL() typedef struct xbt_automaton_state { char* id; int type; /* -1 = init, 0 = inter, 1 = final */ xbt_dynar_t in; xbt_dynar_t out; } s_xbt_automaton_state; typedef struct xbt_automaton_state* xbt_automaton_state_t; typedef struct xbt_automaton { xbt_dynar_t propositional_symbols; xbt_dynar_t transitions; xbt_dynar_t states; xbt_automaton_state_t current_state; } s_xbt_automaton; typedef struct xbt_automaton* xbt_automaton_t; typedef struct xbt_automaton_exp_label{ enum{AUT_OR=0, AUT_AND=1, AUT_NOT=2, AUT_PREDICAT=3, AUT_ONE=4} type; union{ struct{ struct xbt_automaton_exp_label* left_exp; struct xbt_automaton_exp_label* right_exp; }or_and; struct xbt_automaton_exp_label* exp_not; char* predicat; }u; } s_xbt_automaton_exp_label; typedef struct xbt_automaton_exp_label* xbt_automaton_exp_label_t; typedef struct xbt_automaton_transition { xbt_automaton_state_t src; xbt_automaton_state_t dst; xbt_automaton_exp_label_t label; } s_xbt_automaton_transition; typedef struct xbt_automaton_transition* xbt_automaton_transition_t; typedef struct xbt_automaton_propositional_symbol{ char* pred; void* function; } s_xbt_automaton_propositional_symbol; typedef struct xbt_automaton_propositional_symbol* xbt_automaton_propositional_symbol_t; XBT_PUBLIC(xbt_automaton_t) xbt_automaton_new(void); XBT_PUBLIC(void) xbt_automaton_load(xbt_automaton_t automaton, const char *file); XBT_PUBLIC(xbt_automaton_state_t) xbt_automaton_state_new(xbt_automaton_t a, int type, char* id); XBT_PUBLIC(xbt_automaton_transition_t) xbt_automaton_transition_new(xbt_automaton_t a, xbt_automaton_state_t src, xbt_automaton_state_t dst, xbt_automaton_exp_label_t label); XBT_PUBLIC(xbt_automaton_exp_label_t) xbt_automaton_exp_label_new(int type, ...); XBT_PUBLIC(xbt_dynar_t) xbt_automaton_get_states(xbt_automaton_t a); XBT_PUBLIC(xbt_dynar_t) xbt_automaton_get_transitions(xbt_automaton_t a); XBT_PUBLIC(xbt_automaton_transition_t) xbt_automaton_get_transition(xbt_automaton_t a, xbt_automaton_state_t src, xbt_automaton_state_t dst); XBT_PUBLIC(xbt_automaton_state_t) xbt_automaton_transition_get_source(xbt_automaton_transition_t t); XBT_PUBLIC(xbt_automaton_state_t) xbt_automaton_transition_get_destination(xbt_automaton_transition_t t); XBT_PUBLIC(void) xbt_automaton_transition_set_source(xbt_automaton_transition_t t, xbt_automaton_state_t src); XBT_PUBLIC(void) xbt_automaton_transition_set_destination(xbt_automaton_transition_t t, xbt_automaton_state_t dst); XBT_PUBLIC(xbt_dynar_t) xbt_automaton_state_get_out_transitions(xbt_automaton_state_t s); XBT_PUBLIC(xbt_dynar_t) xbt_automaton_state_get_in_transitions(xbt_automaton_state_t s); XBT_PUBLIC(xbt_automaton_state_t) xbt_automaton_state_exists(xbt_automaton_t a, char *id); XBT_PUBLIC(void) xbt_automaton_display(xbt_automaton_t a); XBT_PUBLIC(void) xbt_automaton_exp_label_display(xbt_automaton_exp_label_t l); XBT_PUBLIC(xbt_automaton_propositional_symbol_t) xbt_automaton_propositional_symbol_new(xbt_automaton_t a, const char* id, void* fct); XBT_PUBLIC(xbt_automaton_state_t) xbt_automaton_get_current_state(xbt_automaton_t a); XBT_PUBLIC(int) xbt_automaton_state_compare(xbt_automaton_state_t s1, xbt_automaton_state_t s2); XBT_PUBLIC(int) xbt_automaton_propositional_symbols_compare_value(xbt_dynar_t s1, xbt_dynar_t s2); XBT_PUBLIC(int) xbt_automaton_transition_compare(const void *t1, const void *t2); XBT_PUBLIC(int) xbt_automaton_exp_label_compare(xbt_automaton_exp_label_t l1, xbt_automaton_exp_label_t l2); XBT_PUBLIC(void) xbt_automaton_state_free_voidp(void *s); XBT_PUBLIC(void) xbt_automaton_state_free(xbt_automaton_state_t s); XBT_PUBLIC(void) xbt_automaton_transition_free_voidp(void *t); XBT_PUBLIC(void) xbt_automaton_exp_label_free_voidp(void *e); XBT_PUBLIC(void) xbt_automaton_propositional_symbol_free_voidp(void *ps); XBT_PUBLIC(void) xbt_automaton_free(xbt_automaton_t a); SG_END_DECL() #endif SimGrid-3.11/include/xbt/xbt_os_thread.h000644 001750 001750 00000011743 12342443646 017260 0ustar00cici000000 000000 /* xbt/xbt_os_thread.h -- Thread portability layer */ /* Copyright (c) 2007-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_OS_THREAD_H #define _XBT_OS_THREAD_H #include "simgrid_config.h" /* Windows or Posix */ #include "xbt/function_types.h" SG_BEGIN_DECL() /** @addtogroup XBT_thread * @brief Thread portability layer * * This section describes the thread portability layer. It defines types and * functions very close to the pthread API, but it's portable to windows too. * * @{ */ /** \brief Thread data type (opaque structure) */ typedef struct xbt_os_thread_ *xbt_os_thread_t; #include #ifdef _XBT_WIN32 /* defined if this is a windows system, 32bits or 64bits) */ #include typedef DWORD xbt_os_thread_key_t; #else /* assume that every non-windows system is POSIX-compatible */ typedef pthread_key_t xbt_os_thread_key_t; #endif /** Calls pthread_atfork() if present, and raise an exception otherwise. * * The only known user of this wrapper is mmalloc_preinit(), but it is absolutely mandatory there: * when used with tesh, mmalloc *must* be mutex protected and resistant to forks. * This functionality is the only way to get it working (by ensuring that the mutex is consistently released on forks) */ XBT_PUBLIC(int) xbt_os_thread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void)); XBT_PUBLIC(int) xbt_os_get_numcores(void); XBT_PUBLIC(xbt_os_thread_t) xbt_os_thread_create(const char *name, pvoid_f_pvoid_t start_routine, void *param, void *data); XBT_PUBLIC(void) xbt_os_thread_exit(int *retcode); XBT_PUBLIC(void) xbt_os_thread_detach(xbt_os_thread_t thread); XBT_PUBLIC(xbt_os_thread_t) xbt_os_thread_self(void); XBT_PUBLIC(const char *) xbt_os_thread_self_name(void); XBT_PUBLIC(const char *) xbt_os_thread_name(xbt_os_thread_t); XBT_PUBLIC(void) xbt_os_thread_set_extra_data(void *data); XBT_PUBLIC(void *) xbt_os_thread_get_extra_data(void); XBT_PUBLIC(void) xbt_os_thread_key_create(xbt_os_thread_key_t* key); XBT_PUBLIC(void) xbt_os_thread_set_specific(xbt_os_thread_key_t key, void* value); XBT_PUBLIC(void*) xbt_os_thread_get_specific(xbt_os_thread_key_t key); /* xbt_os_thread_join frees the joined thread (ie the XBT wrapper around it, the OS frees the rest) */ XBT_PUBLIC(void) xbt_os_thread_join(xbt_os_thread_t thread, void **thread_return); XBT_PUBLIC(void) xbt_os_thread_yield(void); XBT_PUBLIC(void) xbt_os_thread_cancel(xbt_os_thread_t thread); XBT_PUBLIC(void *) xbt_os_thread_getparam(void); XBT_PUBLIC(void) xbt_os_thread_setstacksize(int stack_size); XBT_PUBLIC(void) xbt_os_thread_setguardsize(int guard_size); /** \brief Thread mutex data type (opaque structure) */ typedef struct xbt_os_mutex_ *xbt_os_mutex_t; XBT_PUBLIC(xbt_os_mutex_t) xbt_os_mutex_init(void); XBT_PUBLIC(void) xbt_os_mutex_acquire(xbt_os_mutex_t mutex); XBT_PUBLIC(void) xbt_os_mutex_timedacquire(xbt_os_mutex_t mutex, double delay); XBT_PUBLIC(void) xbt_os_mutex_release(xbt_os_mutex_t mutex); XBT_PUBLIC(void) xbt_os_mutex_destroy(xbt_os_mutex_t mutex); /** \brief Thread reentrant mutex data type (opaque structure) */ typedef struct xbt_os_rmutex_ *xbt_os_rmutex_t; XBT_PUBLIC(xbt_os_rmutex_t) xbt_os_rmutex_init(void); XBT_PUBLIC(void) xbt_os_rmutex_acquire(xbt_os_rmutex_t rmutex); XBT_PUBLIC(void) xbt_os_rmutex_release(xbt_os_rmutex_t rmutex); XBT_PUBLIC(void) xbt_os_rmutex_destroy(xbt_os_rmutex_t rmutex); /** \brief Thread condition data type (opaque structure) */ typedef struct xbt_os_cond_ *xbt_os_cond_t; XBT_PUBLIC(xbt_os_cond_t) xbt_os_cond_init(void); XBT_PUBLIC(void) xbt_os_cond_wait(xbt_os_cond_t cond, xbt_os_mutex_t mutex); XBT_PUBLIC(void) xbt_os_cond_timedwait(xbt_os_cond_t cond, xbt_os_mutex_t mutex, double delay); XBT_PUBLIC(void) xbt_os_cond_signal(xbt_os_cond_t cond); XBT_PUBLIC(void) xbt_os_cond_broadcast(xbt_os_cond_t cond); XBT_PUBLIC(void) xbt_os_cond_destroy(xbt_os_cond_t cond); /** \brief Semaphore data type (opaque structure) */ typedef struct xbt_os_sem_ *xbt_os_sem_t; XBT_PUBLIC(xbt_os_sem_t) xbt_os_sem_init(unsigned int value); XBT_PUBLIC(void) xbt_os_sem_acquire(xbt_os_sem_t sem); XBT_PUBLIC(void) xbt_os_sem_timedacquire(xbt_os_sem_t sem, double timeout); XBT_PUBLIC(void) xbt_os_sem_release(xbt_os_sem_t sem); XBT_PUBLIC(void) xbt_os_sem_destroy(xbt_os_sem_t sem); XBT_PUBLIC(void) xbt_os_sem_get_value(xbt_os_sem_t sem, int *svalue); /** @} */ SG_END_DECL() #endif /* _XBT_OS_THREAD_H */ SimGrid-3.11/include/xbt/peer.h000644 001750 001750 00000002400 12342443646 015354 0ustar00cici000000 000000 /* peer.h - peer (remote processes) management functions */ /* Copyright (c) 2006-2007, 2009-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef XBT_PEER_H #define XBT_PEER_H #include "xbt/misc.h" SG_BEGIN_DECL() /** @addtogroup XBT_peer * \brief Helper functions to manipulate remote hosts * * This module simply introduces some rather trivial functions to manipulate remote host denomination (in the form hostname:port) * * @{ */ /** @brief Object describing a remote host (as name:port) */ typedef struct s_xbt_peer *xbt_peer_t; /** @brief Structure describing a remote host (as name:port) */ typedef struct s_xbt_peer { char *name; int port; } s_xbt_peer_t; XBT_PUBLIC(xbt_peer_t) xbt_peer_new(const char *name, int port); XBT_PUBLIC(xbt_peer_t) xbt_peer_from_string(const char *peerport); XBT_PUBLIC(xbt_peer_t) xbt_peer_copy(xbt_peer_t h); XBT_PUBLIC(void) xbt_peer_free(xbt_peer_t peer); XBT_PUBLIC(void) xbt_peer_free_voidp(void *d); /** @} */ SG_END_DECL() #endif /* XBT_PEER_H */ SimGrid-3.11/include/xbt/graphxml.h000644 001750 001750 00000013720 12342443646 016252 0ustar00cici000000 000000 /* XML processor/application API for src/xbt/graphxml.dtd. * * This program was generated with the FleXML XML processor generator. * FleXML is Copyright (C) 1999-2005 Kristoffer Rose. All rights reserved. * FleXML is Copyright (C) 2003-2013 Martin Quinson. All rights reserved. * (1.9.6). * * There are two, intertwined parts to this program, part A and part B. * * Part A * ------ * * Some parts, here collectively called "Part A", are found in the * FleXML package. They are Copyright (C) 1999-2005 Kristoffer Rose * and Copyright (C) 2003-2013 Martin Quinson. All rights reserved. * * You can redistribute, use, perform, display and/or modify "Part A" * provided the following two conditions hold: * * 1. The program is distributed WITHOUT ANY WARRANTY from the author of * FleXML; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. * * 2. The program distribution conditions do not in any way affect the * distribution conditions of the FleXML system used to generate this * file or any version of FleXML derived from that system. * * Notice that these are explicit rights granted to you for files * generated by the FleXML system. For your rights in connection with * the FleXML system itself please consult the GNU General Public License. * * Part B * ------ * * The other parts, here collectively called "Part B", and which came * from the DTD used by FleXML to generate this program, can be * distributed (or not, as the case may be) under the terms of whoever * wrote them, provided these terms respect and obey the two conditions * above under the heading "Part A". * * The author of and contributors to FleXML specifically disclaim * any copyright interest in "Part B", unless "Part B" was written * by the author of or contributors to FleXML. * */ #ifndef _FLEXML_graphxml_H #define _FLEXML_graphxml_H /* XML application entry points. */ XBT_PUBLIC(void) STag_graphxml_graph(void); XBT_PUBLIC(void) ETag_graphxml_graph(void); XBT_PUBLIC(void) STag_graphxml_node(void); XBT_PUBLIC(void) ETag_graphxml_node(void); XBT_PUBLIC(void) STag_graphxml_edge(void); XBT_PUBLIC(void) ETag_graphxml_edge(void); /* XML application data. */ typedef int AT_graphxml_edge_source; #define AU_graphxml_edge_source NULL typedef int AT_graphxml_node_name; #define AU_graphxml_node_name NULL typedef int AT_graphxml_node_data; #define AU_graphxml_node_data NULL typedef int AT_graphxml_node_position___y; #define AU_graphxml_node_position___y NULL typedef enum { AU_graphxml_graph_isDirected, A_graphxml_graph_isDirected_true,A_graphxml_graph_isDirected_false } AT_graphxml_graph_isDirected; typedef int AT_graphxml_edge_data; #define AU_graphxml_edge_data NULL typedef int AT_graphxml_edge_name; #define AU_graphxml_edge_name NULL typedef int AT_graphxml_edge_length; #define AU_graphxml_edge_length NULL typedef int AT_graphxml_edge_label; #define AU_graphxml_edge_label NULL typedef int AT_graphxml_node_position___x; #define AU_graphxml_node_position___x NULL typedef int AT_graphxml_node_label; #define AU_graphxml_node_label NULL typedef int AT_graphxml_edge_target; #define AU_graphxml_edge_target NULL /* FleXML-provided data. */ XBT_PUBLIC_DATA(int) graphxml_pcdata_ix; XBT_PUBLIC_DATA(char *) graphxml_bufferstack; #define graphxml_pcdata (graphxml_bufferstack + graphxml_pcdata_ix) XBT_PUBLIC_DATA(AT_graphxml_edge_source) AX_graphxml_edge_source; #define A_graphxml_edge_source (graphxml_bufferstack + AX_graphxml_edge_source) XBT_PUBLIC_DATA(short int) graphxml_edge_source_isset; XBT_PUBLIC_DATA(AT_graphxml_node_name) AX_graphxml_node_name; #define A_graphxml_node_name (graphxml_bufferstack + AX_graphxml_node_name) XBT_PUBLIC_DATA(short int) graphxml_node_name_isset; XBT_PUBLIC_DATA(AT_graphxml_node_data) AX_graphxml_node_data; #define A_graphxml_node_data (graphxml_bufferstack + AX_graphxml_node_data) XBT_PUBLIC_DATA(short int) graphxml_node_data_isset; XBT_PUBLIC_DATA(AT_graphxml_node_position___y) AX_graphxml_node_position___y; #define A_graphxml_node_position___y (graphxml_bufferstack + AX_graphxml_node_position___y) XBT_PUBLIC_DATA(short int) graphxml_node_position___y_isset; XBT_PUBLIC_DATA(AT_graphxml_graph_isDirected) AX_graphxml_graph_isDirected; #define A_graphxml_graph_isDirected AX_graphxml_graph_isDirected XBT_PUBLIC_DATA(short int) graphxml_graph_isDirected_isset; XBT_PUBLIC_DATA(AT_graphxml_edge_data) AX_graphxml_edge_data; #define A_graphxml_edge_data (graphxml_bufferstack + AX_graphxml_edge_data) XBT_PUBLIC_DATA(short int) graphxml_edge_data_isset; XBT_PUBLIC_DATA(AT_graphxml_edge_name) AX_graphxml_edge_name; #define A_graphxml_edge_name (graphxml_bufferstack + AX_graphxml_edge_name) XBT_PUBLIC_DATA(short int) graphxml_edge_name_isset; XBT_PUBLIC_DATA(AT_graphxml_edge_length) AX_graphxml_edge_length; #define A_graphxml_edge_length (graphxml_bufferstack + AX_graphxml_edge_length) XBT_PUBLIC_DATA(short int) graphxml_edge_length_isset; XBT_PUBLIC_DATA(AT_graphxml_edge_label) AX_graphxml_edge_label; #define A_graphxml_edge_label (graphxml_bufferstack + AX_graphxml_edge_label) XBT_PUBLIC_DATA(short int) graphxml_edge_label_isset; XBT_PUBLIC_DATA(AT_graphxml_node_position___x) AX_graphxml_node_position___x; #define A_graphxml_node_position___x (graphxml_bufferstack + AX_graphxml_node_position___x) XBT_PUBLIC_DATA(short int) graphxml_node_position___x_isset; XBT_PUBLIC_DATA(AT_graphxml_node_label) AX_graphxml_node_label; #define A_graphxml_node_label (graphxml_bufferstack + AX_graphxml_node_label) XBT_PUBLIC_DATA(short int) graphxml_node_label_isset; XBT_PUBLIC_DATA(AT_graphxml_edge_target) AX_graphxml_edge_target; #define A_graphxml_edge_target (graphxml_bufferstack + AX_graphxml_edge_target) XBT_PUBLIC_DATA(short int) graphxml_edge_target_isset; /* XML application utilities. */ XBT_PUBLIC(int) graphxml_element_context(int); /* XML processor entry point. */ XBT_PUBLIC(int) yylex(void); /* Flexml error handling function (useful only when -q flag passed to flexml) */ const char * graphxml_parse_err_msg(void); #endif SimGrid-3.11/include/xbt/set.h000644 001750 001750 00000010441 12342443646 015220 0ustar00cici000000 000000 /* xbt/set.h -- api to a generic dictionary */ /* Copyright (c) 2004-2007, 2009-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_SET_H #define _XBT_SET_H #include "xbt/misc.h" /* SG_BEGIN_DECL */ #include "xbt/function_types.h" SG_BEGIN_DECL() /** @addtogroup XBT_set * @brief A data container consisting in \ref XBT_dict and \ref XBT_dynar * * The elements stored in such a data structure can be retrieve both by * name and by ID. For this to work, the first fields of the structures * stored must begin with the following fields: \verbatim struct { unsigned int ID; char *name; unsigned int name_len; // my other fields, constituting the payload } my_element_type_t; \endverbatim * * Since we are casting elements around, no protection is ensured by the * compiler. It is thus safer to define the headers using the macro * defined to that extend: * \verbatim struct { XBT_SET_HEADERS; // my other fields, constituting the payload } my_element_type_t; \endverbatim * * It is now possible to remove an element from such a data structure. * * @todo * Such a datastructure was necessary/useful to store the GRAS type * descriptions, but it should be reworked to become generic. * */ /** @defgroup XBT_set_cons Set and set elements, constructor/destructor * @ingroup XBT_set * * @{ */ /** \brief Opaque type representing a set */ typedef struct xbt_set_ *xbt_set_t; #define XBT_SET_HEADERS \ unsigned int ID; \ char *name; \ unsigned int name_len /** \brief It must be possible to cast set elements to this type */ typedef struct xbt_set_elm_ { unsigned int ID; /**< Identificator (system assigned) */ char *name; /**< Name (user assigned) */ unsigned int name_len; /**< Length of the name */ } s_xbt_set_elm_t, *xbt_set_elm_t; /*####[ Functions ]##########################################################*/ XBT_PUBLIC(xbt_set_t) xbt_set_new(void); XBT_PUBLIC(void) xbt_set_free(xbt_set_t * set); /** @} */ /** @defgroup XBT_set_basic Sets basic usage * @ingroup XBT_set * * @{ */ XBT_PUBLIC(void) xbt_set_add(xbt_set_t set, xbt_set_elm_t elm, void_f_pvoid_t free_func); XBT_PUBLIC(void) xbt_set_remove(xbt_set_t set, xbt_set_elm_t elm); XBT_PUBLIC(void) xbt_set_remove_by_name(xbt_set_t set, const char *key); XBT_PUBLIC(xbt_set_elm_t) xbt_set_get_by_name_or_null(xbt_set_t set, const char *key); XBT_PUBLIC(void) xbt_set_remove_by_name_ext(xbt_set_t set, const char *key, int key_len); XBT_PUBLIC(void) xbt_set_remove_by_id(xbt_set_t set, int id); XBT_PUBLIC(xbt_set_elm_t) xbt_set_get_by_name(xbt_set_t set, const char *key); XBT_PUBLIC(xbt_set_elm_t) xbt_set_get_by_name_ext(xbt_set_t set, const char *key, int key_len); XBT_PUBLIC(xbt_set_elm_t) xbt_set_get_by_id(xbt_set_t set, int id); XBT_PUBLIC(unsigned long) xbt_set_length(const xbt_set_t set); /** @} */ /** @defgroup XBT_set_curs Sets cursors * @ingroup XBT_set * * \warning Don't add or remove entries to the cache while traversing * * @{ */ /** @brief Cursor type */ typedef struct xbt_set_cursor_ *xbt_set_cursor_t; XBT_PUBLIC(void) xbt_set_cursor_first(xbt_set_t set, xbt_set_cursor_t * cursor); XBT_PUBLIC(void) xbt_set_cursor_step(xbt_set_cursor_t cursor); XBT_PUBLIC(int) xbt_set_cursor_get_or_free(xbt_set_cursor_t * cursor, xbt_set_elm_t * elm); /** @brief Iterates over the whole set * @hideinitializer */ #define xbt_set_foreach(set,cursor,elm) \ for ((cursor) = NULL, xbt_set_cursor_first((set),&(cursor)) ; \ xbt_set_cursor_get_or_free(&(cursor),(xbt_set_elm_t*)&(elm)); \ xbt_set_cursor_step(cursor) ) /* @} */ SG_END_DECL() #endif /* _XBT_SET_H */ SimGrid-3.11/include/xbt/dynar.h000644 001750 001750 00000023155 12342443646 015550 0ustar00cici000000 000000 /* dynar - a generic dynamic array */ /* Copyright (c) 2004-2007, 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_DYNAR_H #define _XBT_DYNAR_H #include /* memcpy */ #include "xbt/misc.h" /* SG_BEGIN_DECL */ #include "xbt/function_types.h" SG_BEGIN_DECL() /** @addtogroup XBT_dynar * @brief DynArr are dynamically sized vector which may contain any type of variables. * * These are the SimGrid version of the dynamically size arrays, which all C programmer recode one day or another. * * For performance concerns, the content of DynArr must be homogeneous (in * contrary to dictionnaries -- see the \ref XBT_dict section). You thus * have to provide the function which will be used to free the content at * structure creation (of type void_f_ppvoid_t or void_f_pvoid_t). * * \section XBT_dynar_exscal Example with scalar * \dontinclude dynar.c * * \skip Vars_decl * \skip dyn * \until iptr * \skip Populate_ints * \skip dyn * \until end_of_traversal * \skip shifting * \skip val * \until xbt_dynar_free * * \section XBT_dynar_exptr Example with pointed data * * \skip test_dynar_string * \skip dynar_t * \until s2 * \skip Populate_str * \skip dyn * \until } * \skip macro * \until dynar_free * \skip end_of_doxygen * \until } * * Note that if you use dynars to store pointed data, the * xbt_dynar_search(), xbt_dynar_search_or_negative() and * xbt_dynar_member() won't be for you. Instead of comparing * your pointed elements, they compare the pointer to them. See * the documentation of xbt_dynar_search() for more info. * */ /** @defgroup XBT_dynar_cons Dynar constructor and destructor * @ingroup XBT_dynar * * @{ */ /** \brief Dynar data type (opaque type) */ typedef struct xbt_dynar_s *xbt_dynar_t; XBT_PUBLIC(xbt_dynar_t) xbt_dynar_new(const unsigned long elm_size, void_f_pvoid_t const free_f); XBT_PUBLIC(void) xbt_dynar_free(xbt_dynar_t * dynar); XBT_PUBLIC(void) xbt_dynar_free_voidp(void *dynar); XBT_PUBLIC(void) xbt_dynar_free_container(xbt_dynar_t * dynar); XBT_PUBLIC(void) xbt_dynar_shrink(xbt_dynar_t dynar, int empty_slots); XBT_PUBLIC(void) xbt_dynar_dump(xbt_dynar_t dynar); /** @} */ /** @defgroup XBT_dynar_array Dynar as a regular array * @ingroup XBT_dynar * * @{ */ XBT_PUBLIC(void) xbt_dynar_get_cpy(const xbt_dynar_t dynar, const unsigned long idx, void *const dst); XBT_PUBLIC(void) xbt_dynar_set(xbt_dynar_t dynar, const int idx, const void *src); XBT_PUBLIC(void) xbt_dynar_replace(xbt_dynar_t dynar, const unsigned long idx, const void *object); XBT_PUBLIC(void) xbt_dynar_insert_at(xbt_dynar_t const dynar, const int idx, const void *src); XBT_PUBLIC(void) xbt_dynar_remove_at(xbt_dynar_t const dynar, const int idx, void *const dst); XBT_PUBLIC(void) xbt_dynar_remove_n_at(xbt_dynar_t const dynar, const unsigned int n, const int idx); XBT_PUBLIC(unsigned int) xbt_dynar_search(xbt_dynar_t const dynar, void *elem); XBT_PUBLIC(signed int) xbt_dynar_search_or_negative(xbt_dynar_t const dynar, void *const elem); XBT_PUBLIC(int) xbt_dynar_member(xbt_dynar_t const dynar, void *elem); XBT_PUBLIC(void) xbt_dynar_sort(xbt_dynar_t const dynar, int_f_cpvoid_cpvoid_t compar_fn); XBT_PUBLIC(void) xbt_dynar_three_way_partition(xbt_dynar_t const dynar, int_f_pvoid_t color); XBT_PUBLIC(int) xbt_dynar_compare(xbt_dynar_t d1, xbt_dynar_t d2, int(*compar)(const void *, const void *)); XBT_PUBLIC(void *) xbt_dynar_to_array (xbt_dynar_t dynar); /** @} */ /** @defgroup XBT_dynar_misc Dynar miscellaneous functions * @ingroup XBT_dynar * * @{ */ XBT_PUBLIC(unsigned long) xbt_dynar_length(const xbt_dynar_t dynar); XBT_PUBLIC(int) xbt_dynar_is_empty(const xbt_dynar_t dynar); XBT_PUBLIC(void) xbt_dynar_reset(xbt_dynar_t const dynar); XBT_PUBLIC(void) xbt_dynar_merge(xbt_dynar_t *d1, xbt_dynar_t *d2); /** @} */ /** @defgroup XBT_dynar_perl Perl-like use of dynars * @ingroup XBT_dynar * * @{ */ XBT_PUBLIC(void) xbt_dynar_push(xbt_dynar_t const dynar, const void *src); XBT_PUBLIC(void) xbt_dynar_pop(xbt_dynar_t const dynar, void *const dst); XBT_PUBLIC(void) xbt_dynar_unshift(xbt_dynar_t const dynar, const void *src); XBT_PUBLIC(void) xbt_dynar_shift(xbt_dynar_t const dynar, void *const dst); XBT_PUBLIC(void) xbt_dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op); /** @} */ /** @defgroup XBT_dynar_ctn Direct manipulation to the dynars content * @ingroup XBT_dynar * * Those functions do not retrieve the content, but only their address. * * @{ */ XBT_PUBLIC(void *) xbt_dynar_set_at_ptr(const xbt_dynar_t dynar, const unsigned long idx); XBT_PUBLIC(void *) xbt_dynar_get_ptr(const xbt_dynar_t dynar, const unsigned long idx); XBT_PUBLIC(void *) xbt_dynar_insert_at_ptr(xbt_dynar_t const dynar, const int idx); XBT_PUBLIC(void *) xbt_dynar_push_ptr(xbt_dynar_t const dynar); XBT_PUBLIC(void *) xbt_dynar_pop_ptr(xbt_dynar_t const dynar); /** @} */ /** @defgroup XBT_dynar_speed Speed optimized access to dynars of scalars * @ingroup XBT_dynar * * While the other functions use a memcpy to retrieve the content into the * user provided area, those ones use a regular affectation. It only works * for scalar values, but should be a little faster. * * @{ */ /** @brief Quick retrieval of scalar content * @hideinitializer */ # define xbt_dynar_get_as(dynar,idx,type) \ (*(type*)xbt_dynar_get_ptr((dynar),(idx))) /** @brief Quick setting of scalar content * @hideinitializer */ # define xbt_dynar_set_as(dynar,idx,type,val) \ (*(type*)xbt_dynar_set_at_ptr((dynar),(idx))) = val /** @brief Quick retrieval of scalar content * @hideinitializer */ # define xbt_dynar_getlast_as(dynar,type) \ (*(type*)xbt_dynar_get_ptr((dynar),xbt_dynar_length(dynar)-1)) /** @brief Quick retrieval of scalar content * @hideinitializer */ # define xbt_dynar_getfirst_as(dynar,type) \ (*(type*)xbt_dynar_get_ptr((dynar),0)) /** @brief Quick insertion of scalar content * @hideinitializer */ # define xbt_dynar_insert_at_as(dynar,idx,type,value) \ *(type*)xbt_dynar_insert_at_ptr(dynar,idx)=value /** @brief Quick insertion of scalar content * @hideinitializer */ # define xbt_dynar_push_as(dynar,type,value) \ *(type*)xbt_dynar_push_ptr(dynar)=value /** @brief Quick removal of scalar content * @hideinitializer */ # define xbt_dynar_pop_as(dynar,type) \ (*(type*)xbt_dynar_pop_ptr(dynar)) /** @} */ /** @defgroup XBT_dynar_cursor Cursors on dynar * @ingroup XBT_dynar * * Cursors are used to iterate over the structure. Never add elements to the * DynArr during the traversal. To remove elements, use the * xbt_dynar_cursor_rm() function. * * Do not call these function directly, but only within the xbt_dynar_foreach * macro. * * @{ */ XBT_PUBLIC(void) xbt_dynar_cursor_rm(xbt_dynar_t dynar, unsigned int *const cursor); /* do not use this structure internals directly, but use the public interface * This was made public to allow: * - the inlining of the foreach elements * - sending such beasts over the network */ typedef struct xbt_dynar_s { unsigned long size; unsigned long used; unsigned long elmsize; void *data; void_f_pvoid_t free_f; } s_xbt_dynar_t; static XBT_INLINE void _xbt_dynar_cursor_first(const xbt_dynar_t dynar _XBT_GNUC_UNUSED, unsigned int *const cursor) { /* iterating over a NULL dynar is a no-op (but we don't want to have uninitialized counters) */ //XBT_DEBUG("Set cursor on %p to the first position", (void *) dynar); *cursor = 0; } static XBT_INLINE int _xbt_dynar_cursor_get(const xbt_dynar_t dynar, unsigned int idx, void *const dst) { if (!dynar) /* iterating over a NULL dynar is a no-op */ return FALSE; if (idx >= dynar->used) { //XBT_DEBUG("Cursor on %p already on last elem", (void *) dynar); return FALSE; } // XBT_DEBUG("Cash out cursor on %p at %u", (void *) dynar, *idx); memcpy(dst, ((char *) dynar->data) + idx * dynar->elmsize, dynar->elmsize); return TRUE; } /** @brief Iterates over the whole dynar. * * @param _dynar what to iterate over * @param _cursor an integer used as cursor * @param _data * @hideinitializer * * Here is an example of usage: * \code xbt_dynar_t dyn; unsigned int cpt; string *str; xbt_dynar_foreach (dyn,cpt,str) { printf("Seen %s\n",str); } \endcode * * Note that underneath, that's a simple for loop with no real black * magic involved. It's perfectly safe to interrupt a foreach with a * break or a return statement. */ #define xbt_dynar_foreach(_dynar,_cursor,_data) \ for (_xbt_dynar_cursor_first(_dynar,&(_cursor)) ; \ _xbt_dynar_cursor_get(_dynar,_cursor,&_data) ; \ (_cursor)++ ) /** @} */ SG_END_DECL() #endif /* _XBT_DYNAR_H */ SimGrid-3.11/include/xbt/function_types.h000644 001750 001750 00000002206 12342443646 017476 0ustar00cici000000 000000 /* function_type.h - classical types for pointer to function */ /* Copyright (c) 2006-2007, 2009-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef XBT_FUNCTION_TYPE_H #define XBT_FUNCTION_TYPE_H #include "xbt/misc.h" SG_BEGIN_DECL() typedef void (*void_f_ppvoid_t) (void **); typedef void (*void_f_pvoid_t) (void *); typedef void (*void_f_int_pvoid_t) (int, void *); typedef void *(*pvoid_f_void_t) (void); typedef void *(*pvoid_f_pvoid_t) (void *); typedef void (*void_f_void_t) (void); typedef int (*int_f_void_t) (void); typedef int (*int_f_pvoid_t) (void*); typedef int (*int_f_pvoid_pvoid_t) (void *, void *); typedef int (*int_f_cpvoid_cpvoid_t) (const void *, const void *); typedef int (*xbt_main_func_t) (int argc, char *argv[]); typedef double(*double_f_pvoid_t) (void *); typedef double(*double_f_cpvoid_t) (const void *); SG_END_DECL() #endif /* XBT_FUNCTION_TYPE_H */ SimGrid-3.11/include/xbt/mallocator.h000644 001750 001750 00000004507 12342443646 016570 0ustar00cici000000 000000 /* xbt/mallocator.h -- api to recycle allocated objects */ /* Copyright (c) 2006-2007, 2009-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_MALLOCATOR_H #define _XBT_MALLOCATOR_H #include "xbt/function_types.h" #include "xbt/misc.h" /* SG_BEGIN_DECL */ SG_BEGIN_DECL() /** @addtogroup XBT_mallocator * @brief The mallocator system * * This section describes the API to a mallocator. * A mallocator allows you to recycle the objects you don't need anymore * instead of freeing them. A mallocator is a stack which stores the unused objects * or a given type. If you often need to malloc() / free() objects of a certain * type, you should use a mallocator and call \a xbt_mallocator_get() and * \a xbt_mallocator_release() instead of malloc() and free(). * * When you release an object, it is not freed but it is stored * into the mallocator (unless the mallocator is full). And when you want to get a * new object, the object is just extracted from the mallocator. No malloc() is * done, unless there is no more object in the mallocator. */ /** @defgroup XBT_mallocator_cons Mallocator constructor and destructor * @ingroup XBT_mallocator * * @{ */ /** \brief Mallocator data type (opaque structure) */ typedef struct s_xbt_mallocator *xbt_mallocator_t; XBT_PUBLIC(xbt_mallocator_t) xbt_mallocator_new(int size, pvoid_f_void_t new_f, void_f_pvoid_t free_f, void_f_pvoid_t reset_f); XBT_PUBLIC(void) xbt_mallocator_free(xbt_mallocator_t mallocator); /** @} */ /* object handling */ /** @defgroup XBT_mallocator_objects Mallocator object handling * @ingroup XBT_mallocator * * @{ */ XBT_PUBLIC(void *) xbt_mallocator_get(xbt_mallocator_t mallocator); XBT_PUBLIC(void) xbt_mallocator_release(xbt_mallocator_t mallocator, void *object); XBT_PUBLIC(void) xbt_mallocator_initialization_is_done(int protect); /** @} */ SG_END_DECL() #endif /* _XBT_MALLOCATOR_H */ SimGrid-3.11/include/xbt/swag.h000644 001750 001750 00000012367 12342443646 015377 0ustar00cici000000 000000 /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /* Warning, this module is done to be efficient and performs tons of cast and dirty things. So avoid using it unless you really know what you are doing. */ #ifndef _XBT_SWAG_H #define _XBT_SWAG_H #include "xbt/misc.h" #include "xbt/sysdep.h" /* size_t */ SG_BEGIN_DECL() /** * @addtogroup XBT_swag * @brief a O(1) set based on linked lists * * Warning, this module is done to be efficient and performs tons of * cast and dirty things. So make sure you know what you are doing while using it. * It is basically a fifo but with restrictions so that * it can be used as a set. Any operation (add, remove, belongs) is O(1) and * no call to malloc/free is done. * */ /** @defgroup XBT_swag_type Swag types @ingroup XBT_swag Specific set. These typedefs are public so that the compiler can do his job but believe me, you don't want to try to play with those structs directly. Use them as an abstract datatype. */ /* @{ */ typedef struct xbt_swag_hookup { void *next; void *prev; } s_xbt_swag_hookup_t; /**< This type should be added to a type that is to be used in a swag. * * Whenever a new object with this struct is created, all fields have * to be set to NULL * * Here is an example like that : \code typedef struct foo { s_xbt_swag_hookup_t set1_hookup; s_xbt_swag_hookup_t set2_hookup; double value; } s_foo_t, *foo_t; ... { s_foo_t elem; xbt_swag_t set1=NULL; xbt_swag_t set2=NULL; set1 = xbt_swag_new(xbt_swag_offset(elem, set1_hookup)); set2 = xbt_swag_new(xbt_swag_offset(elem, set2_hookup)); } \endcode */ typedef s_xbt_swag_hookup_t *xbt_swag_hookup_t; typedef struct xbt_swag { void *head; void *tail; size_t offset; int count; } s_xbt_swag_t, *xbt_swag_t; /**< A typical swag */ /* @} */ /** @defgroup XBT_swag_func SWAG functions * @ingroup XBT_swag * @{ */ XBT_PUBLIC(xbt_swag_t) xbt_swag_new(size_t offset); XBT_PUBLIC(void) xbt_swag_free(xbt_swag_t swag); XBT_PUBLIC(void) xbt_swag_init(xbt_swag_t swag, size_t offset); /** * \brief Makes a swag empty. * \param swag a swag * @hideinitializer */ #define xbt_swag_reset(swag) do {} while(xbt_swag_extract(swag)) /** * \param obj the objet to insert in the swag * \param swag a swag * @hideinitializer * * insert \a obj in \a swag */ #define xbt_swag_insert(obj, swag) xbt_swag_insert_at_tail(obj, swag) XBT_PUBLIC(void) xbt_swag_insert_at_head(void *obj, xbt_swag_t swag); XBT_PUBLIC(void) xbt_swag_insert_at_tail(void *obj, xbt_swag_t swag); XBT_PUBLIC(void *) xbt_swag_remove(void *obj, xbt_swag_t swag); XBT_PUBLIC(void *) xbt_swag_extract(xbt_swag_t swag); XBT_PUBLIC(int) xbt_swag_size(xbt_swag_t swag); #define xbt_swag_getPrev(obj, offset) (((xbt_swag_hookup_t)(((char *) (obj)) + (offset)))->prev) #define xbt_swag_getNext(obj, offset) (((xbt_swag_hookup_t)(((char *) (obj)) + (offset)))->next) #define xbt_swag_belongs(obj, swag) (xbt_swag_getNext((obj), (swag)->offset) || (swag)->tail == (obj)) static XBT_INLINE void *xbt_swag_getFirst(xbt_swag_t swag) { return (swag->head); } /** * \brief Offset computation * \arg var a variable of type struct something * \arg field a field of struct something * \return the offset of \a field in struct something. * @hideinitializer * * It is very similar to offsetof except that is done at runtime and that * you have to declare a variable. Why defining such a macro then ? * Because it is portable... */ #define xbt_swag_offset(var,field) ((char *)&( (var).field ) - (char *)&(var)) /* @} */ /** * \defgroup XBT_swag_curs Swag cursor * @ingroup XBT_swag * Iterates over the whole swag. * * @{ */ /** @brief A simple swag iterator * @param obj the indice of the loop * @param swag what to iterate over * @warning you cannot modify the \a swag while using this loop * @hideinitializer */ #define xbt_swag_foreach(obj,swag) \ for((obj)=xbt_swag_getFirst((swag)); \ (obj)!=NULL; \ (obj)=xbt_swag_getNext((obj),(swag)->offset)) /** * @brief A safe swag iterator * @param obj the indice of the loop * @param obj_next the object that is right after (if any) \a obj in the swag * @param swag what to iterate over * @hideinitializer You can safely modify the \a swag while using this loop. Well, safely... Err. You can remove \a obj without having any trouble at least. */ #define xbt_swag_foreach_safe(obj,obj_next,swag) \ for((obj)=xbt_swag_getFirst((swag)), \ ((obj)?(obj_next=xbt_swag_getNext((obj),(swag)->offset)): \ (obj_next=NULL)); \ (obj)!=NULL; \ (obj)=obj_next, \ ((obj)?(obj_next=xbt_swag_getNext((obj),(swag)->offset)): \ (obj_next=NULL)) ) /* @} */ SG_END_DECL() #endif /* _XBT_SWAG_H */ SimGrid-3.11/include/xbt/dict.h000644 001750 001750 00000020107 12342443646 015350 0ustar00cici000000 000000 /* xbt/dict.h -- api to a generic dictionary */ /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_DICT_H #define _XBT_DICT_H #include "xbt/misc.h" /* SG_BEGIN_DECL */ #include "xbt/dynar.h" /* void_f_pvoid_t */ #include /* uintptr_t */ SG_BEGIN_DECL() /** @addtogroup XBT_dict * @brief The dictionary data structure (comparable to hash tables) * * This section describes the API to a dictionary structure that * associates as string to a void* key. It provides the same * functionality than an hash table. * * Here is a little example of use: \verbatim xbt_dict_t mydict = xbt_dict_new(); char buff[512]; sprintf(buff,"some very precious data"); xbt_dict_set(mydict,"my data", strdup(buff), free); sprintf(buff,"another good stuff"); xbt_dict_set(mydict,"my data", strdup(buff), free); // previous data gets erased (and freed) by second add \endverbatim * */ /** @defgroup XBT_dict_cons Dict constructor and destructor * @ingroup XBT_dict * * @{ */ /** \brief Dictionary data type (opaque structure) */ typedef struct s_xbt_dict *xbt_dict_t; typedef struct s_xbt_dictelm *xbt_dictelm_t; typedef struct s_xbt_dictelm { char *key; int key_len; unsigned int hash_code; void *content; xbt_dictelm_t next; } s_xbt_dictelm_t; XBT_PUBLIC(xbt_dict_t) xbt_dict_new(void); XBT_PUBLIC(xbt_dict_t) xbt_dict_new_homogeneous(void_f_pvoid_t free_ctn); XBT_PUBLIC(void) xbt_dict_free(xbt_dict_t * dict); XBT_PUBLIC(unsigned int) xbt_dict_size(xbt_dict_t dict); /** @} */ /** @defgroup XBT_dict_basic Dictionaries basic usage * @ingroup XBT_dict * * Careful, those functions assume that the key is null-terminated. * * @{ */ XBT_PUBLIC(void) xbt_dict_set(xbt_dict_t dict, const char *key, void *data, void_f_pvoid_t free_ctn); XBT_PUBLIC(void *) xbt_dict_get(xbt_dict_t dict, const char *key); XBT_PUBLIC(void *) xbt_dict_get_or_null(xbt_dict_t dict, const char *key); XBT_PUBLIC(char *) xbt_dict_get_key(xbt_dict_t dict, const void *data); XBT_PUBLIC(xbt_dictelm_t) xbt_dict_get_elm(xbt_dict_t dict, const char *key); XBT_PUBLIC(xbt_dictelm_t) xbt_dict_get_elm_or_null(xbt_dict_t dict, const char *key); XBT_PUBLIC(void) xbt_dict_remove(xbt_dict_t dict, const char *key); XBT_PUBLIC(void) xbt_dict_reset(xbt_dict_t dict); XBT_PUBLIC(int) xbt_dict_length(xbt_dict_t dict); XBT_PUBLIC(void) xbt_dict_dump_output_string(void *s); XBT_PUBLIC(void) xbt_dict_dump(xbt_dict_t dict, void (*output) (void *)); XBT_PUBLIC(void) xbt_dict_dump_sizes(xbt_dict_t dict); XBT_PUBLIC(int) xbt_dict_is_empty(xbt_dict_t dict); /** @} */ /** @defgroup XBT_dict_nnul Dictionaries with non-nul terminated keys * @ingroup XBT_dict * * Those functions work even with non-null terminated keys. * * @{ */ XBT_PUBLIC(void) xbt_dict_set_ext(xbt_dict_t dict, const char *key, int key_len, void *data, void_f_pvoid_t free_ctn); XBT_PUBLIC(void *) xbt_dict_get_ext(xbt_dict_t dict, const char *key, int key_len); XBT_PUBLIC(void *) xbt_dict_get_or_null_ext(xbt_dict_t dict, const char *key, int key_len); XBT_PUBLIC(void) xbt_dict_remove_ext(xbt_dict_t dict, const char *key, int key_len); #ifdef XBT_USE_DEPRECATED XBT_PUBLIC(void) xbt_dicti_set(xbt_dict_t dict, uintptr_t key, uintptr_t data); XBT_PUBLIC(uintptr_t) xbt_dicti_get(xbt_dict_t dict, uintptr_t key); XBT_PUBLIC(void) xbt_dicti_remove(xbt_dict_t dict, uintptr_t key); #endif struct s_xbt_dict_cursor { xbt_dictelm_t current; int line; xbt_dict_t dict; }; /** @} */ /** @defgroup XBT_dict_curs Cursors on dictionaries * @ingroup XBT_dict * * Don't get impressed, there is a lot of functions here, but traversing a * dictionary is immediate with the xbt_dict_foreach macro. * You only need the other functions in rare cases (they are not used directly in SG itself). * * Here is an example (assuming that the dictionary contains strings, ie * that the data argument of xbt_dict_set was always a null-terminated char*): \verbatim xbt_dict_cursor_t cursor=NULL; char *key,*data; xbt_dict_foreach(dict,cursor,key,data) { printf(" - Seen: %s->%s\n",key,data); }\endverbatim * * \warning Do not add or remove entries to the cache while traversing !! * * @{ */ /** @brief Cursor on dictionaries (opaque type) */ typedef struct s_xbt_dict_cursor *xbt_dict_cursor_t; static inline xbt_dictelm_t xbt_dict_cursor_get_elm(xbt_dict_cursor_t cursor) { return cursor->current; } XBT_PUBLIC(xbt_dict_cursor_t) xbt_dict_cursor_new(const xbt_dict_t dict); XBT_PUBLIC(void) xbt_dict_cursor_free(xbt_dict_cursor_t * cursor); XBT_PUBLIC(void) xbt_dict_cursor_rewind(xbt_dict_cursor_t cursor); xbt_dictelm_t xbt_dict_cursor_get_elm(xbt_dict_cursor_t cursor); XBT_PUBLIC(char *) xbt_dict_cursor_get_key(xbt_dict_cursor_t cursor); XBT_PUBLIC(void *) xbt_dict_cursor_get_data(xbt_dict_cursor_t cursor); XBT_PUBLIC(void) xbt_dict_cursor_set_data(xbt_dict_cursor_t cursor, void *data, void_f_pvoid_t free_ctn); XBT_PUBLIC(void) xbt_dict_cursor_first(const xbt_dict_t dict, xbt_dict_cursor_t * cursor); XBT_PUBLIC(void) xbt_dict_cursor_step(xbt_dict_cursor_t cursor); XBT_PUBLIC(int) xbt_dict_cursor_get_or_free(xbt_dict_cursor_t * cursor, char **key, void **data); /** @def xbt_dict_foreach * @param dict a \ref xbt_dict_t iterator * @param cursor an \ref xbt_dict_cursor_t used as cursor * @param key a char* * @param data a void** output * @hideinitializer * * \note An example of usage: * \code xbt_dict_cursor_t cursor = NULL; char *key; char *data; xbt_dict_foreach(head, cursor, key, data) { printf("Key %s with data %s\n",key,data); } \endcode */ # define xbt_dict_foreach(dict,cursor,key,data) \ for (cursor=NULL, xbt_dict_cursor_first((dict),&(cursor)) ; \ xbt_dict_cursor_get_or_free(&(cursor),(char**)&(key),(void**)(&data));\ xbt_dict_cursor_step(cursor) ) /** @} */ #ifdef XBT_USE_DEPRECATED /** @defgroup XBT_dict_multi Multi-level dictionaries * @ingroup XBT_dict * * They can be seen as dictionary of multiple keys or as dictionary of * dictionary of ... of data. Most of the functions here work the same way * than their simple dictionary counterpart. * * Note that there is no xbt_multidict_free neither xbt_multi_dict_new functions. * Use xbt_dict_free() and xbt_dict_new() instead. * * @{ */ /*----[ xbt_multidict_set ]--------------------------------------------------*/ XBT_PUBLIC(void) xbt_multidict_set(xbt_dict_t mdict, xbt_dynar_t keys, void *data, void (*free_ctn) (void *)); XBT_PUBLIC(void) xbt_multidict_set_ext(xbt_dict_t mdict, xbt_dynar_t keys, xbt_dynar_t lens, void *data, void_f_pvoid_t free_ctn); /*----[ xbt_multidict_get ]--------------------------------------------------*/ XBT_PUBLIC(void *) xbt_multidict_get(xbt_dict_t mdict, xbt_dynar_t keys); XBT_PUBLIC(void *) xbt_multidict_get_ext(xbt_dict_t mdict, xbt_dynar_t keys, xbt_dynar_t lens); /*----[ xbt_multidict_remove ]-----------------------------------------------*/ /*---------------------------------------------------------------------------*/ XBT_PUBLIC(void) xbt_multidict_remove(xbt_dict_t mdict, xbt_dynar_t keys); XBT_PUBLIC(void) xbt_multidict_remove_ext(xbt_dict_t mdict, xbt_dynar_t keys, xbt_dynar_t lens); /** @} */ #endif SG_END_DECL() #endif /* _XBT_DICT_H */ SimGrid-3.11/include/xbt/asserts.h000644 001750 001750 00000003510 12342443646 016110 0ustar00cici000000 000000 /* xbt/asserts.h -- assertion mecanism */ /* Copyright (c) 2005-2007, 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_ASSERTS_H #define _XBT_ASSERTS_H #include "xbt/misc.h" #include "xbt/log.h" #include "xbt/ex.h" SG_BEGIN_DECL() /** * @addtogroup XBT_error * @brief Those are the SimGrid version of the good ol' assert macro. * * You can pass them a format message and arguments, just as if it where a * printf. * It is converted to a XBT_CRITICAL logging request. * Be careful: the boolean expression that you want to test should not have * side effects, because assertions are disabled at compile time if NDEBUG * is set. * * @{ */ #ifdef NDEBUG #define xbt_assert(...) ((void)0) #else /** @brief The condition which failed will be displayed. @hideinitializer */ #define xbt_assert(...) \ _XBT_IF_ONE_ARG(_xbt_assert_ARG1, _xbt_assert_ARGN, __VA_ARGS__)(__VA_ARGS__) #define _xbt_assert_ARG1(cond) \ _xbt_assert_ARGN(cond, "Assertion %s failed", #cond) #define _xbt_assert_ARGN(cond, ...) \ do { if (!(cond)) THROWF(0, 0, __VA_ARGS__); } while (0) #endif #ifdef XBT_USE_DEPRECATED #define xbt_assert0(...) xbt_assert(__VA_ARGS__) #define xbt_assert1(...) xbt_assert(__VA_ARGS__) #define xbt_assert2(...) xbt_assert(__VA_ARGS__) #define xbt_assert3(...) xbt_assert(__VA_ARGS__) #define xbt_assert4(...) xbt_assert(__VA_ARGS__) #define xbt_assert5(...) xbt_assert(__VA_ARGS__) #define xbt_assert6(...) xbt_assert(__VA_ARGS__) #endif /** @} */ SG_END_DECL() #endif /* _XBT_ASSERTS_H */ SimGrid-3.11/include/xbt/RngStream.h000644 001750 001750 00000003054 12342443646 016331 0ustar00cici000000 000000 /* Copyright (c) 2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /* RngStream.h for ANSI C */ #ifndef RNGSTREAM_H #define RNGSTREAM_H #include "misc.h" typedef struct RngStream_InfoState * RngStream; struct RngStream_InfoState { double Cg[6], Bg[6], Ig[6]; int Anti; int IncPrec; char *name; }; XBT_PUBLIC(int) RngStream_SetPackageSeed (unsigned long seed[6]); XBT_PUBLIC(RngStream) RngStream_CreateStream (const char name[]); XBT_PUBLIC(void) RngStream_DeleteStream (RngStream *pg); XBT_PUBLIC(RngStream) RngStream_CopyStream (const RngStream src); XBT_PUBLIC(void) RngStream_ResetStartStream (RngStream g); XBT_PUBLIC(void) RngStream_ResetStartSubstream (RngStream g); XBT_PUBLIC(void) RngStream_ResetNextSubstream (RngStream g); XBT_PUBLIC(void) RngStream_SetAntithetic (RngStream g, int a); XBT_PUBLIC(void) RngStream_IncreasedPrecis (RngStream g, int incp); XBT_PUBLIC(int) RngStream_SetSeed (RngStream g, unsigned long seed[6]); XBT_PUBLIC(void) RngStream_AdvanceState (RngStream g, long e, long c); XBT_PUBLIC(void) RngStream_GetState (RngStream g, unsigned long seed[6]); XBT_PUBLIC(void) RngStream_WriteState (RngStream g); XBT_PUBLIC(void) RngStream_WriteStateFull (RngStream g); XBT_PUBLIC(double) RngStream_RandU01 (RngStream g); XBT_PUBLIC(int) RngStream_RandInt (RngStream g, int i, int j); #endif SimGrid-3.11/include/xbt/hash.h000644 001750 001750 00000001761 12342443646 015355 0ustar00cici000000 000000 /* hash.h - Various hashing functions. */ /* Copyright (c) 2008-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef XBT_HASH_H #define XBT_HASH_H #include "xbt/str.h" /* Chord needs a SHA1 algorithm. Let's drop it in there */ typedef struct s_xbt_sha_ s_xbt_sha_t, *xbt_sha_t; XBT_PUBLIC(xbt_sha_t) xbt_sha_new(void); XBT_PUBLIC(void) xbt_sha_free(xbt_sha_t sha); XBT_PUBLIC(void) xbt_sha_feed(xbt_sha_t sha, const unsigned char *data, size_t len); XBT_PUBLIC(void) xbt_sha_reset(xbt_sha_t sha); XBT_PUBLIC(void) xbt_sha_print(xbt_sha_t sha, char *hash); XBT_PUBLIC(char *) xbt_sha_read(xbt_sha_t sha); XBT_PUBLIC(void) xbt_sha(const char *data, char *hash); #endif /* XBT_HASH_H */ SimGrid-3.11/include/xbt/setset.h000644 001750 001750 00000005220 12342443646 015733 0ustar00cici000000 000000 /* Copyright (c) 2010, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_SETSET_H #define _XBT_SETSET_H #include "xbt/misc.h" typedef struct s_xbt_setset *xbt_setset_t; typedef struct s_xbt_setset_set *xbt_setset_set_t; typedef struct s_xbt_setset_cursor *xbt_setset_cursor_t; #define XBT_SETSET_HEADERS \ unsigned long ID /* Constructor */ xbt_setset_t xbt_setset_new(unsigned int size); /* Destructor */ void xbt_setset_destroy(xbt_setset_t setset); /* Add an object to the setset, this will calculate its ID */ void xbt_setset_elm_add(xbt_setset_t setset, void *obj); /* Remove an object from the setset */ void xbt_setset_elm_remove(xbt_setset_t setset, void *obj); /* Create a new set in the setset */ xbt_setset_set_t xbt_setset_new_set(xbt_setset_t setset); /* Destroy a set in the setset */ void xbt_setset_destroy_set(xbt_setset_set_t); /* Insert an element into a set */ void xbt_setset_set_insert(xbt_setset_set_t set, void *obj); /* Remove an element from a set */ void xbt_setset_set_remove(xbt_setset_set_t set, void *obj); /* Remove all the elements of a set */ void xbt_setset_set_reset(xbt_setset_set_t set); /* Select one element of a set */ void *xbt_setset_set_choose(xbt_setset_set_t set); /* Extract one element of a set */ void *xbt_setset_set_extract(xbt_setset_set_t set); /* Test if an element belongs to a set */ int xbt_setset_set_belongs(xbt_setset_set_t set, void *obj); /* Get the number of elements in a set */ int xbt_setset_set_size(xbt_setset_set_t set); /* Add all elements of set2 to set1 */ void xbt_setset_add(xbt_setset_set_t set1, xbt_setset_set_t set2); /* Substract all elements of set2 from set1 */ void xbt_setset_substract(xbt_setset_set_t set1, xbt_setset_set_t set2); /* Intersect set1 and set2 storing the result in set1 */ void xbt_setset_intersect(xbt_setset_set_t set1, xbt_setset_set_t set2); /* Get the cursor to point to the first element of a set */ void xbt_setset_cursor_first(xbt_setset_set_t set, xbt_setset_cursor_t * cursor); /* Get the data pointed by a cursor */ int xbt_setset_cursor_get_data(xbt_setset_cursor_t cursor, void **data); /* Advance a cursor to the next element */ void xbt_setset_cursor_next(xbt_setset_cursor_t cursor); #define xbt_setset_foreach(set, cursor, data) \ for(xbt_setset_cursor_first(set, &cursor); \ xbt_setset_cursor_get_data(cursor, (void **)&data); \ xbt_setset_cursor_next(cursor)) #endif SimGrid-3.11/include/xbt/config.h000644 001750 001750 00000023122 12342443646 015672 0ustar00cici000000 000000 /* config - Dictionary where the type of each cell is provided. */ /* This is useful to build named structs, like option or property sets. */ /* Copyright (c) 2004-2007, 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_CONFIG_H_ #define _XBT_CONFIG_H_ #include #include "xbt/dynar.h" SG_BEGIN_DECL() /** @addtogroup XBT_config * @brief Changing the configuration of SimGrid components (grounding feature) * * All modules of the SimGrid toolkit can be configured with this API. * User modules and libraries can also use these facilities to handle * their own configuration. * * A configuration set contain several \e variables which have a unique name * in the set and can take a given type of value. For example, it may * contain a \a size variable, accepting \e int values. * * It is impossible to set a value to a variable which has not been registered before. * Usually, the module registers all the options it accepts in the configuration set, * during its initialization and user code then set and unset values. * * The easiest way to register a variable is to use the xbt_str_register_str function, * which accepts a string representation of the config element descriptor. The syntax * is the following: \verbatim :_to__\endverbatim * * For example, size:1_to_1_int describes a variable called \e size which * must take exactly one value, and the value being an integer. Set the maximum to 0 to * disable the upper bound on data count. * * Another example could be outputfiles:0_to_10_string which describes a variable * called \e outputfiles and which can take between 0 and 10 strings as value. * * To some extend, configuration sets can be seen as typed hash structures. * * * \section XBT_cfg_ex Example of use * * \dontinclude config.c * * First, let's create a configuration set with some registered variables. * This must be done by the configurable library before the user interactions. * * \skip make_set * \until end_of_make_set * * Now, set and get a single value * \skip get_single_value * \skip int * \until cfg_free * * And now, set and get a multiple value * \skip get_multiple_value * \skip dyn * \until cfg_free * * All those functions throws mismatch_error if asked to deal with an * unregistered variable. * \skip myset * \until cfg_free * */ /** @defgroup XBT_cfg_use User interface: changing values * @ingroup XBT_config * * This is the only interface you should use unless you want to let your * own code become configurable with this. * * If the variable accept at most one value, those functions replace the * current value with the provided one. If max>1, the provided value is * appended to the list. * * string values are strdup'ed before use, so you can (and should) free * your copy * * @{ */ /** @brief Configuration set's data type is opaque. */ typedef void* xbt_cfg_t; XBT_PUBLIC(void) xbt_cfg_set(xbt_cfg_t cfg, const char *name, ...); XBT_PUBLIC(void) xbt_cfg_set_vargs(xbt_cfg_t cfg, const char *name, va_list pa); XBT_PUBLIC(void) xbt_cfg_set_parse(xbt_cfg_t cfg, const char *options); /* Set the value of the cell \a name in \a cfg with the provided value. */ XBT_PUBLIC(void) xbt_cfg_set_int(xbt_cfg_t cfg, const char *name, int val); XBT_PUBLIC(void) xbt_cfg_set_double(xbt_cfg_t cfg, const char *name, double val); XBT_PUBLIC(void) xbt_cfg_set_string(xbt_cfg_t cfg, const char *name, const char *val); XBT_PUBLIC(void) xbt_cfg_set_boolean(xbt_cfg_t cfg, const char *name, const char *val); XBT_PUBLIC(void) xbt_cfg_set_peer(xbt_cfg_t cfg, const char *name, const char *peer, int port); XBT_PUBLIC(void*) xbt_cfg_set_as_string(xbt_cfg_t cfg, const char *name, const char *val); /* Set the default value of the cell \a name in \a cfg with the provided value. If it was already set to something (possibly from the command line), do nothing. */ XBT_PUBLIC(void) xbt_cfg_setdefault_int(xbt_cfg_t cfg, const char *name, int val); XBT_PUBLIC(void) xbt_cfg_setdefault_double(xbt_cfg_t cfg, const char *name, double val); XBT_PUBLIC(void) xbt_cfg_setdefault_string(xbt_cfg_t cfg, const char *name, const char *val); XBT_PUBLIC(void) xbt_cfg_setdefault_boolean(xbt_cfg_t cfg, const char *name, const char *val); XBT_PUBLIC(void) xbt_cfg_setdefault_peer(xbt_cfg_t cfg, const char *name, const char *host, int port); /* Remove the provided value from the cell @name in @cfg. */ XBT_PUBLIC(void) xbt_cfg_rm_int(xbt_cfg_t cfg, const char *name, int val); XBT_PUBLIC(void) xbt_cfg_rm_double(xbt_cfg_t cfg, const char *name, double val); XBT_PUBLIC(void) xbt_cfg_rm_string(xbt_cfg_t cfg, const char *name, const char *val); XBT_PUBLIC(void) xbt_cfg_rm_boolean(xbt_cfg_t cfg, const char *name, int val); XBT_PUBLIC(void) xbt_cfg_rm_peer(xbt_cfg_t cfg, const char *name, const char *peer, int port); /* Remove the value at position \e pos from the config \e cfg */ XBT_PUBLIC(void) xbt_cfg_rm_at(xbt_cfg_t cfg, const char *name, int pos); /* rm every values */ XBT_PUBLIC(void) xbt_cfg_empty(xbt_cfg_t cfg, const char *name); /* Return if configuration is set by default*/ XBT_PUBLIC(int) xbt_cfg_is_default_value(xbt_cfg_t cfg, const char *name); /* @} */ /** @defgroup XBT_cfg_decl Configuration type declaration and memory management * @ingroup XBT_config * * @{ */ /** @brief possible content of each configuration cell */ typedef enum { xbt_cfgelm_int = 0, /**< int */ xbt_cfgelm_double, /**< double */ xbt_cfgelm_string, /**< char* */ xbt_cfgelm_boolean, /**< int */ xbt_cfgelm_peer, /**< both a char* (representing the peername) and an integer (representing the port) */ xbt_cfgelm_any, /* not shown to users to prevent errors */ xbt_cfgelm_type_count } e_xbt_cfgelm_type_t; /** Boolean possible values **/ struct xbt_boolean_couple { const char *true_val; const char *false_val; }; /** \brief Callback types. They get the name of the modified entry, and the position of the changed value */ typedef void (*xbt_cfg_cb_t) (const char *, int); XBT_PUBLIC(xbt_cfg_t) xbt_cfg_new(void); XBT_PUBLIC(void) xbt_cfg_cpy(xbt_cfg_t tocopy, /* OUT */ xbt_cfg_t * whereto); XBT_PUBLIC(void) xbt_cfg_free(xbt_cfg_t * cfg); XBT_PUBLIC(void) xbt_cfg_dump(const char *name, const char *indent, xbt_cfg_t cfg); /** @} */ /** @defgroup XBT_cfg_register Registering stuff * @ingroup XBT_config * * This how to add new variables to an existing configuration set. Use it to make your code * configurable. * * @{ */ XBT_PUBLIC(void) xbt_cfg_register(xbt_cfg_t * cfg, const char *name, const char *description, e_xbt_cfgelm_type_t type, int min, int max, xbt_cfg_cb_t cb_set, xbt_cfg_cb_t cb_rm); XBT_PUBLIC(void) xbt_cfg_unregister(xbt_cfg_t cfg, const char *name); XBT_PUBLIC(void) xbt_cfg_register_str(xbt_cfg_t * cfg, const char *entry); XBT_PUBLIC(void) xbt_cfg_help(xbt_cfg_t cfg); XBT_PUBLIC(void) xbt_cfg_check(xbt_cfg_t cfg); XBT_PUBLIC(e_xbt_cfgelm_type_t) xbt_cfg_get_type(xbt_cfg_t cfg, const char *name); /* @} */ /** @defgroup XBT_cfg_get Getting the stored values * @ingroup XBT_config * * This is how to retrieve the values stored in the configuration set. This is only * intended to configurable code, naturally. * * Note that those function return a pointer to the values actually stored * in the set. Do not modify them unless you really know what you're doing. * Likewise, do not free the strings after use, they are not copy of the data, * but the data themselves. * * @{ */ XBT_PUBLIC(int) xbt_cfg_get_int(xbt_cfg_t cfg, const char *name); XBT_PUBLIC(double) xbt_cfg_get_double(xbt_cfg_t cfg, const char *name); XBT_PUBLIC(char *) xbt_cfg_get_string(xbt_cfg_t cfg, const char *name); XBT_PUBLIC(int) xbt_cfg_get_boolean(xbt_cfg_t cfg, const char *name); XBT_PUBLIC(void) xbt_cfg_get_peer(xbt_cfg_t cfg, const char *name, char **peer, int *port); XBT_PUBLIC(xbt_dynar_t) xbt_cfg_get_dynar(xbt_cfg_t cfg, const char *name); XBT_PUBLIC(int) xbt_cfg_get_int_at(xbt_cfg_t cfg, const char *name, int pos); XBT_PUBLIC(double) xbt_cfg_get_double_at(xbt_cfg_t cfg, const char *name, int pos); XBT_PUBLIC(char *) xbt_cfg_get_string_at(xbt_cfg_t cfg, const char *name, int pos); XBT_PUBLIC(int) xbt_cfg_get_boolean_at(xbt_cfg_t cfg, const char *name, int pos); XBT_PUBLIC(void) xbt_cfg_get_peer_at(xbt_cfg_t cfg, const char *name, int pos, char **peer, int *port); /** @} */ SG_END_DECL() #endif /* _XBT_CONFIG_H_ */ SimGrid-3.11/include/xbt/queue.h000644 001750 001750 00000005155 12342443646 015557 0ustar00cici000000 000000 /* A (synchronized) message queue. */ /* Popping an empty queue is blocking, as well as pushing a full one */ /* Copyright (c) 2007, 2009-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_QUEUE_H #define _XBT_QUEUE_H #include "xbt/misc.h" /* SG_BEGIN_DECL */ /* #include "xbt/function_types.h" */ SG_BEGIN_DECL() /** @addtogroup XBT_queue * \brief Synchronized message exchanging queue. * * These is the classical producer/consumer synchronization scheme, * which all concurrent programmer recode one day or another. * * The good thing of this implementation is that it works seamlessly * in your universe. When using one of the classical simulation * interface (such as MSG), it achieves the synchronization on top * of the simulator. If you use instead the real life implementation * comming with GRAS, it uses the synchronization of your OS * (whatever could it be). The choice is done at link time. * * For performance concerns, the content of queue must be homogeneous, * just like dynars (see the \ref XBT_dynar section). Actually, queues use a * dynar to store the data, and add the synchronization on top of it. * * @{ */ /** \brief Queue data type (opaque type) */ typedef struct s_xbt_queue_ *xbt_queue_t; XBT_PUBLIC(xbt_queue_t) xbt_queue_new(int capacity, unsigned long elm_size); XBT_PUBLIC(void) xbt_queue_free(xbt_queue_t * queue); XBT_PUBLIC(unsigned long) xbt_queue_length(const xbt_queue_t queue); XBT_PUBLIC(void) xbt_queue_push(xbt_queue_t queue, const void *src); XBT_PUBLIC(void) xbt_queue_pop(xbt_queue_t queue, void *const dst); XBT_PUBLIC(void) xbt_queue_unshift(xbt_queue_t queue, const void *src); XBT_PUBLIC(void) xbt_queue_shift(xbt_queue_t queue, void *const dst); XBT_PUBLIC(void) xbt_queue_push_timed(xbt_queue_t queue, const void *src, double delay); XBT_PUBLIC(void) xbt_queue_unshift_timed(xbt_queue_t queue, const void *src, double delay); XBT_PUBLIC(void) xbt_queue_shift_timed(xbt_queue_t queue, void *const dst, double delay); XBT_PUBLIC(void) xbt_queue_pop_timed(xbt_queue_t queue, void *const dst, double delay); /** @} */ SG_END_DECL() #endif /* _XBT_QUEUE_H */ SimGrid-3.11/include/xbt/str.h000644 001750 001750 00000010042 12342443646 015232 0ustar00cici000000 000000 /* str.h - XBT string related functions. */ /* Copyright (c) 2007-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef XBT_STR_H #define XBT_STR_H #include /* va_* */ #include "xbt/misc.h" #include "xbt/dynar.h" #include "xbt/dict.h" #include "simgrid_config.h" /* FILE for getline */ SG_BEGIN_DECL() /** @addtogroup XBT_str * @brief String manipulation functions * * This module defines several string related functions. We redefine some quite classical * functions on the platforms were they are not nativaly defined (such as xbt_getline() or * asprintf()), while some other are a bit more exotic. * @{ */ /* Our own implementation of getline, mainly useful on the platforms not enjoying this function */ #include /* FILE */ #include /* size_t, ssize_t */ XBT_PUBLIC(ssize_t) xbt_getline(char **lineptr, size_t * n, FILE * stream); /* Trim related functions */ XBT_PUBLIC(void) xbt_str_rtrim(char *s, const char *char_list); XBT_PUBLIC(void) xbt_str_ltrim(char *s, const char *char_list); XBT_PUBLIC(void) xbt_str_trim(char *s, const char *char_list); XBT_PUBLIC(xbt_dynar_t) xbt_str_split(const char *s, const char *sep); XBT_PUBLIC(xbt_dynar_t) xbt_str_split_quoted(const char *s); XBT_PUBLIC(xbt_dynar_t) xbt_str_split_quoted_in_place(char *s); XBT_PUBLIC(xbt_dynar_t) xbt_str_split_str(const char *s, const char *sep); XBT_PUBLIC(char *) xbt_str_join(xbt_dynar_t dynar, const char *sep); XBT_PUBLIC(char *) xbt_str_join_array(const char *const *strs, const char *sep); /* */ XBT_PUBLIC(void) xbt_str_subst(char *str, char from, char to, int amount); XBT_PUBLIC(char *) xbt_str_varsubst(const char *str, xbt_dict_t patterns); /* */ XBT_PUBLIC(void) xbt_str_strip_spaces(char *); XBT_PUBLIC(char *) xbt_str_diff(const char *a, const char *b); XBT_PUBLIC(char *) xbt_str_from_file(FILE * file); XBT_PUBLIC(int) xbt_str_start_with(const char* str, const char* start); #define DJB2_HASH_FUNCTION //#define FNV_HASH_FUNCTION /** * @brief Returns the hash code of a string. */ static XBT_INLINE unsigned int xbt_str_hash_ext(const char *str, int str_len) { #ifdef DJB2_HASH_FUNCTION /* fast implementation of djb2 algorithm */ int c; register unsigned int hash = 5381; while (str_len--) { c = *str++; hash = ((hash << 5) + hash) + c; /* hash * 33 + c */ } # elif defined(FNV_HASH_FUNCTION) register unsigned int hash = 0x811c9dc5; unsigned char *bp = (unsigned char *) str; /* start of buffer */ unsigned char *be = bp + str_len; /* beyond end of buffer */ while (bp < be) { /* multiply by the 32 bit FNV magic prime mod 2^32 */ hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24); /* xor the bottom with the current octet */ hash ^= (unsigned int) *bp++; } # else register unsigned int hash = 0; while (str_len--) { hash += (*str) * (*str); str++; } #endif return hash; } /** * @brief Returns the hash code of a string. */ static XBT_INLINE unsigned int xbt_str_hash(const char *str) { #ifdef DJB2_HASH_FUNCTION /* fast implementation of djb2 algorithm */ int c; register unsigned int hash = 5381; while ((c = *str++)) { hash = ((hash << 5) + hash) + c; /* hash * 33 + c */ } # elif defined(FNV_HASH_FUNCTION) register unsigned int hash = 0x811c9dc5; while (*str) { /* multiply by the 32 bit FNV magic prime mod 2^32 */ hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24); /* xor the bottom with the current byte */ hash ^= (unsigned int) *str++; } # else register unsigned int hash = 0; while (*str) { hash += (*str) * (*str); str++; } #endif return hash; } /**@}*/ SG_END_DECL() #endif /* XBT_STR_H */ SimGrid-3.11/include/xbt/module.h000644 001750 001750 00000001207 12342443646 015712 0ustar00cici000000 000000 /* module - modularize the code */ /* Copyright (c) 2004-2007, 2009-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_MODULE_H #define _XBT_MODULE_H #include /* XBT_PUBLIC */ SG_BEGIN_DECL() XBT_PUBLIC(void) xbt_init(int *argc, char **argv); XBT_PUBLIC(void) xbt_exit(void); SG_END_DECL() #endif /* _XBT_MODULE_H */ SimGrid-3.11/include/xbt/heap.h000644 001750 001750 00000002705 12342443646 015346 0ustar00cici000000 000000 /* Copyright (c) 2004-2007, 2009-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_HEAP_H #define _XBT_HEAP_H #include "xbt/misc.h" #include "xbt/dynar.h" /* void_f_pvoid_t */ SG_BEGIN_DECL() /** @addtogroup XBT_heap * @brief This section describes the API to generic heap with O(log(n)) access. * * @{ */ /* @brief heap datatype */ typedef struct xbt_heap *xbt_heap_t; XBT_PUBLIC(xbt_heap_t) xbt_heap_new(int init_size, void_f_pvoid_t const free_func); XBT_PUBLIC(void) xbt_heap_free(xbt_heap_t H); XBT_PUBLIC(int) xbt_heap_size(xbt_heap_t H); XBT_PUBLIC(void) xbt_heap_push(xbt_heap_t H, void *content, double key); XBT_PUBLIC(void *) xbt_heap_pop(xbt_heap_t H); XBT_PUBLIC(double) xbt_heap_maxkey(xbt_heap_t H); XBT_PUBLIC(void *) xbt_heap_maxcontent(xbt_heap_t H); XBT_PUBLIC(void) xbt_heap_set_update_callback(xbt_heap_t H, void (*update_callback) (void *, int)); XBT_PUBLIC(void *) xbt_heap_remove(xbt_heap_t H, int i); /* @} */ SG_END_DECL() #endif /* _XBT_HEAP_H */ SimGrid-3.11/include/xbt/strbuff.h000644 001750 001750 00000002315 12342443646 016101 0ustar00cici000000 000000 /* strbuff -- string buffers */ /* Copyright (c) 2007-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef XBT_STRBUFF_H #define XBT_STRBUFF_H #include "xbt/sysdep.h" #include "xbt/function_types.h" #include "xbt/log.h" #include "xbt/str.h" #include "xbt/dict.h" /** ** Buffer code **/ typedef struct { char *data; int used, size; } s_xbt_strbuff_t, *xbt_strbuff_t; XBT_PUBLIC(void) xbt_strbuff_empty(xbt_strbuff_t b); XBT_PUBLIC(xbt_strbuff_t) xbt_strbuff_new(void); XBT_PUBLIC(xbt_strbuff_t) xbt_strbuff_new_from(const char *s); XBT_PUBLIC(void) xbt_strbuff_free(xbt_strbuff_t b); XBT_PUBLIC(void) xbt_strbuff_free_container(xbt_strbuff_t b); XBT_PUBLIC(void) xbt_strbuff_append(xbt_strbuff_t b, const char *toadd); XBT_PUBLIC(void) xbt_strbuff_chomp(xbt_strbuff_t b); XBT_PUBLIC(void) xbt_strbuff_trim(xbt_strbuff_t b); XBT_PUBLIC(void) xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns); #endif SimGrid-3.11/include/xbt/synchro_core.h000644 001750 001750 00000010557 12342443646 017132 0ustar00cici000000 000000 /* xbt/synchro_core.h -- Synchronization tools */ /* Usable in simulator, (or in real life when mixing with GRAS) */ /* Copyright (c) 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /* splited away from synchro.h since we are used by dynar.h, and synchro.h uses dynar */ #ifndef _XBT_THREAD_H #define _XBT_THREAD_H #include "xbt/misc.h" /* SG_BEGIN_DECL */ #include "xbt/function_types.h" SG_BEGIN_DECL() /** @addtogroup XBT_synchro * @brief XBT synchronization tools * * This section describes the XBT synchronization tools. It defines types and * functions very close to the pthread API, but widly usable. When used from * the simulator, you will lock simulated processes as expected. When used * from GRAS programs compiled for in-situ execution, you have synchronization * mecanism portable to windows and UNIX. Nice, isn't it? * * @{ */ /** @brief Thread data type (opaque object) * @hideinitializer */ typedef struct s_xbt_thread_ *xbt_thread_t; /** @brief Creates a new thread. * * @param name the name used in the logs for the newly created thread * @param start_routine function to run * @param param parameter to pass to the function to run * @param joinable whether the new thread should be started joinable or detached */ XBT_PUBLIC(xbt_thread_t) xbt_thread_create(const char *name, void_f_pvoid_t start_routine, void *param, int joinable); /** @brief Get a reference to the currently running thread */ XBT_PUBLIC(xbt_thread_t) xbt_thread_self(void); /** @brief Get the name of a given thread */ XBT_PUBLIC(const char *) xbt_thread_name(xbt_thread_t t); /** @brief Get a reference to the name of the currently running thread */ XBT_PUBLIC(const char *) xbt_thread_self_name(void); /** @brief Wait for the termination of the given thread, and free it (ie the XBT wrapper around it, the OS frees the rest) */ XBT_PUBLIC(void) xbt_thread_join(xbt_thread_t thread); /** @brief Ends the life of the poor victim (not always working if it's computing, but working if it's blocked in the OS) */ XBT_PUBLIC(void) xbt_thread_cancel(xbt_thread_t thread); /** @brief commit suicide */ XBT_PUBLIC(void) xbt_thread_exit(void); /** @brief the current thread passes control to any possible thread wanting it */ XBT_PUBLIC(void) xbt_thread_yield(void); /** @brief Thread mutex data type (opaque object) * @hideinitializer */ typedef struct s_xbt_mutex_ *xbt_mutex_t; /** @brief Creates a new mutex variable */ XBT_PUBLIC(xbt_mutex_t) xbt_mutex_init(void); /** @brief Blocks onto the given mutex variable */ XBT_PUBLIC(void) xbt_mutex_acquire(xbt_mutex_t mutex); /** @brief Releases the given mutex variable */ XBT_PUBLIC(void) xbt_mutex_release(xbt_mutex_t mutex); /** @brief Destroyes the given mutex variable */ XBT_PUBLIC(void) xbt_mutex_destroy(xbt_mutex_t mutex); /** @brief Thread condition data type (opaque object) * @hideinitializer */ typedef struct s_xbt_cond_ *xbt_cond_t; /** @brief Creates a condition variable */ XBT_PUBLIC(xbt_cond_t) xbt_cond_init(void); /** @brief Blocks onto the given condition variable */ XBT_PUBLIC(void) xbt_cond_wait(xbt_cond_t cond, xbt_mutex_t mutex); /** @brief Blocks onto the given condition variable, but only for the given amount of time. a timeout exception is raised if it was impossible to acquire it in the given time frame */ XBT_PUBLIC(void) xbt_cond_timedwait(xbt_cond_t cond, xbt_mutex_t mutex, double delay); /** @brief Signals the given mutex variable */ XBT_PUBLIC(void) xbt_cond_signal(xbt_cond_t cond); /** @brief Broadcasts the given mutex variable */ XBT_PUBLIC(void) xbt_cond_broadcast(xbt_cond_t cond); /** @brief Destroys the given mutex variable */ XBT_PUBLIC(void) xbt_cond_destroy(xbt_cond_t cond); #define XBT_BARRIER_SERIAL_PROCESS -1 typedef struct s_xbt_bar_ *xbt_bar_t; XBT_PUBLIC(xbt_bar_t) xbt_barrier_init( unsigned int count); XBT_PUBLIC(void) xbt_barrier_destroy(xbt_bar_t bar); XBT_PUBLIC(int) xbt_barrier_wait(xbt_bar_t bar); /** @} */ SG_END_DECL() #endif /* _XBT_THREAD_H */ SimGrid-3.11/include/xbt/replay.h000644 001750 001750 00000003043 12342443646 015721 0ustar00cici000000 000000 /* xbt/replay_reader.h -- Tools to parse a replay file */ /* Copyright (c) 2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef XBT_REPLAY_H #define XBT_REPLAY_H #include "xbt/misc.h" /* SG_BEGIN_DECL */ SG_BEGIN_DECL() typedef struct s_replay_reader *xbt_replay_reader_t; typedef void (*action_fun) (const char *const *args); XBT_PUBLIC_DATA(xbt_dict_t) action_funs; XBT_PUBLIC_DATA(xbt_dict_t) action_queues; /* To split the file if a unique one is given (specific variable for the other case live in runner()) */ XBT_PUBLIC_DATA(FILE *) action_fp; XBT_PUBLIC(xbt_replay_reader_t) xbt_replay_reader_new(const char*filename); XBT_PUBLIC(const char **) xbt_replay_reader_get(xbt_replay_reader_t reader); XBT_PUBLIC(void) xbt_replay_reader_free(xbt_replay_reader_t *reader); XBT_PUBLIC(const char *) xbt_replay_reader_position(xbt_replay_reader_t reader); XBT_PUBLIC(int) xbt_replay_action_runner(int argc, char *argv[]); XBT_PUBLIC(int) _xbt_replay_is_active(void); XBT_PUBLIC(void) _xbt_replay_action_init(void); XBT_PUBLIC(void) _xbt_replay_action_exit(void); XBT_PUBLIC(void) xbt_replay_action_register(const char *action_name, action_fun function); XBT_PUBLIC(void) xbt_replay_action_unregister(const char *action_name); SG_END_DECL() #endif /* XBT_REPLAY_H */ SimGrid-3.11/include/xbt/matrix.h000644 001750 001750 00000005734 12342443646 015742 0ustar00cici000000 000000 /* xbt_matrix_t management functions */ /* Copyright (c) 2006-2007, 2009-2010, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef XBT_MATRIX_H #define XBT_MATRIX_H #include "xbt/misc.h" #include "xbt/function_types.h" SG_BEGIN_DECL() typedef struct { unsigned int lines, rows; unsigned long elmsize; char *data; void_f_pvoid_t free_f; } s_xbt_matrix_t, *xbt_matrix_t; /** @brief Retrieve the address of a cell (not its content) * @hideinitializer */ #define xbt_matrix_get_ptr(mat,l,c) \ ((void*)&(mat)->data[(c)*(mat)->lines*(mat)->elmsize + (l)*(mat)->elmsize]) /** @brief Quick retrieval of scalar content * @hideinitializer */ #define xbt_matrix_get_as(mat,l,c,type) *(type*)xbt_matrix_get_ptr(mat,l,c) XBT_PUBLIC(xbt_matrix_t) xbt_matrix_new(int lines, int rows, const unsigned long elmsize, void_f_pvoid_t const free_f); XBT_PUBLIC(xbt_matrix_t) xbt_matrix_new_sub(xbt_matrix_t from, int lsize, int rsize, int lpos, int rpos, pvoid_f_pvoid_t const cpy_f); XBT_PUBLIC(void) xbt_matrix_free(xbt_matrix_t matrix); XBT_PUBLIC(void) xbt_matrix_free_voidp(void *d); XBT_PUBLIC(void) xbt_matrix_copy_values(xbt_matrix_t dest, xbt_matrix_t src, unsigned int lsize, unsigned int rsize, unsigned int lpos_dst, unsigned int rpos_dst, unsigned int lpos_src, unsigned int rpos_src, pvoid_f_pvoid_t const cpy_f); XBT_PUBLIC(void) xbt_matrix_dump(xbt_matrix_t matrix, const char *name, int coords, void_f_pvoid_t display_fun); XBT_PUBLIC(void) xbt_matrix_dump_display_double(void *d); XBT_PUBLIC(xbt_matrix_t) xbt_matrix_double_new_zeros(int lines, int rows); XBT_PUBLIC(xbt_matrix_t) xbt_matrix_double_new_id(int lines, int rows); XBT_PUBLIC(xbt_matrix_t) xbt_matrix_double_new_rand(int lines, int rows); XBT_PUBLIC(xbt_matrix_t) xbt_matrix_double_new_seq(int lines, int rows); XBT_PUBLIC(int) xbt_matrix_double_is_seq(xbt_matrix_t mat); XBT_PUBLIC(xbt_matrix_t) xbt_matrix_double_new_mult(xbt_matrix_t A, xbt_matrix_t B); XBT_PUBLIC(void) xbt_matrix_double_addmult(xbt_matrix_t A, xbt_matrix_t B, /*OUT*/ xbt_matrix_t C); SG_END_DECL() #endif /* XBT_MATRIX_H */ SimGrid-3.11/include/xbt/log.h000644 001750 001750 00000063226 12342443646 015217 0ustar00cici000000 000000 /* log - a generic logging facility in the spirit of log4j */ /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /** @addtogroup XBT_log * @brief A generic logging facility in the spirit of log4j (grounding feature) * * */ /** \defgroup XBT_log_cats Existing log categories * \ingroup XBT_log * \brief (automatically extracted) * * This is the list of all existing log categories in SimGrid. * This list was automatically extracted from the source code by * the tools/doxygen/xbt_log_extract_hierarchy.pl utility. * * You can thus be certain that it is uptodate, but it may somehow * lack a final manual touch. * Anyway, nothing's perfect ;) */ /* XBT_LOG_MAYDAY: define this to replace the logging facilities with basic printf function. Useful to debug the logging facilities themselves */ #undef XBT_LOG_MAYDAY //#define XBT_LOG_MAYDAY #ifndef _XBT_LOG_H_ #define _XBT_LOG_H_ #include "xbt/misc.h" #include #include /* NULL */ SG_BEGIN_DECL() /**\brief Log priorities * \ingroup XBT_log * * The different existing priorities. */ typedef enum { xbt_log_priority_none = 0, /* used internally (don't poke with) */ xbt_log_priority_trace = 1, /**< enter and return of some functions */ xbt_log_priority_debug = 2, /**< crufty output */ xbt_log_priority_verbose = 3, /**< verbose output for the user wanting more */ xbt_log_priority_info = 4, /**< output about the regular functionning */ xbt_log_priority_warning = 5, /**< minor issue encountered */ xbt_log_priority_error = 6, /**< issue encountered */ xbt_log_priority_critical = 7, /**< major issue encountered */ xbt_log_priority_infinite = 8, /**< value for XBT_LOG_STATIC_THRESHOLD to not log */ xbt_log_priority_uninitialized = -1 /* used internally (don't poke with) */ } e_xbt_log_priority_t; /* * define NLOG to disable at compilation time any logging request * define NDEBUG to disable at compilation time any logging request of priority below VERBOSE */ /** * @def XBT_LOG_STATIC_THRESHOLD * @ingroup XBT_log * * All logging requests with priority < XBT_LOG_STATIC_THRESHOLD are disabled at * compile time, i.e., compiled out. */ #ifdef NLOG # define XBT_LOG_STATIC_THRESHOLD xbt_log_priority_infinite #else # ifdef NDEBUG # define XBT_LOG_STATIC_THRESHOLD xbt_log_priority_verbose # else /* !NLOG && !NDEBUG */ # ifndef XBT_LOG_STATIC_THRESHOLD # define XBT_LOG_STATIC_THRESHOLD xbt_log_priority_none # endif /* !XBT_LOG_STATIC_THRESHOLD */ # endif /* NDEBUG */ #endif /* !defined(NLOG) */ /* Transforms a category name to a global variable name. */ #define _XBT_LOGV(cat) _XBT_LOG_CONCAT(_simgrid_log_category__, cat) #define _XBT_LOGV_CTOR(cat) _XBT_LOG_CONCAT2(_XBT_LOGV(cat), __constructor__) #define _XBT_LOG_CONCAT(x, y) x ## y #define _XBT_LOG_CONCAT2(x, y) _XBT_LOG_CONCAT(x, y) /* Apparently, constructor priorities are not supported by gcc on Macs */ #if defined(__GNUC__) && defined(__APPLE__) # define _XBT_LOGV_CTOR_ATTRIBUTE #else # define _XBT_LOGV_CTOR_ATTRIBUTE _XBT_GNUC_CONSTRUCTOR(600) #endif /* The root of the category hierarchy. */ #define XBT_LOG_ROOT_CAT root /* The whole tree of categories is connected by setting the address of the * parent category as a field of the child one. This is normally done at the * first use of the category. * * It is however necessary to make this connections as early as possible, if we * want the category to be listed by --help-log-categories. * * When possible, the initializations takes place automatically before the start * of main(). It's the case when compiling with gcc. * * For the other cases, you can use the XBT_LOG_CONNECT(cat) macro to force * early initialization. See, for example, in xbt/log.c, the function * xbt_log_connect_categories(). */ #define XBT_LOG_CONNECT(cat) \ if (1) { \ extern void _XBT_LOGV_CTOR(cat)(void); \ _XBT_LOGV_CTOR(cat)(); \ } else ((void)0) /* XBT_LOG_NEW_SUBCATEGORY_helper: * Implementation of XBT_LOG_NEW_SUBCATEGORY, which must declare "extern parent" in addition * to avoid an extra declaration of root when XBT_LOG_NEW_SUBCATEGORY is called by * XBT_LOG_NEW_CATEGORY */ #define XBT_LOG_NEW_SUBCATEGORY_helper(catName, parent, desc) \ SG_BEGIN_DECL() \ XBT_PUBLIC(void) _XBT_LOGV_CTOR(catName)(void) _XBT_LOGV_CTOR_ATTRIBUTE; \ void _XBT_LOGV_CTOR(catName)(void) \ { \ XBT_LOG_EXTERNAL_CATEGORY(catName); \ if (!_XBT_LOGV(catName).initialized) { \ _xbt_log_cat_init(&_XBT_LOGV(catName), xbt_log_priority_uninitialized); \ } \ } \ SG_END_DECL() \ XBT_EXPORT_NO_IMPORT(s_xbt_log_category_t) _XBT_LOGV(catName) = { \ &_XBT_LOGV(parent), \ NULL /* firstChild */, \ NULL /* nextSibling */, \ #catName, \ desc, \ 0 /*initialized */, \ xbt_log_priority_uninitialized /* threshold */, \ 1 /* isThreshInherited */, \ NULL /* appender */, \ NULL /* layout */, \ 1 /* additivity */ \ } /** * \ingroup XBT_log * \param catName name of new category * \param parent father of the new category in the tree * \param desc string describing the purpose of this category * \hideinitializer * * Defines a new subcategory of the parent. */ #define XBT_LOG_NEW_SUBCATEGORY(catName, parent, desc) \ XBT_LOG_EXTERNAL_CATEGORY(parent); \ XBT_LOG_NEW_SUBCATEGORY_helper(catName, parent, desc) \ /** * \ingroup XBT_log * \param catName name of new category * \param desc string describing the purpose of this category * \hideinitializer * * Creates a new subcategory of the root category. */ # define XBT_LOG_NEW_CATEGORY(catName,desc) \ XBT_LOG_NEW_SUBCATEGORY_helper(catName, XBT_LOG_ROOT_CAT, desc) /** * \ingroup XBT_log * \param cname name of the cat * \hideinitializer * * Indicates which category is the default one. */ #if defined(XBT_LOG_MAYDAY) /*|| defined (NLOG) * turning logging off */ # define XBT_LOG_DEFAULT_CATEGORY(cname) #else # define XBT_LOG_DEFAULT_CATEGORY(cname) \ static xbt_log_category_t _XBT_LOGV(default) _XBT_GNUC_UNUSED = &_XBT_LOGV(cname) #endif /** * \ingroup XBT_log * \param cname name of the cat * \param desc string describing the purpose of this category * \hideinitializer * * Creates a new subcategory of the root category and makes it the default * (used by macros that don't explicitly specify a category). */ # define XBT_LOG_NEW_DEFAULT_CATEGORY(cname,desc) \ XBT_LOG_NEW_CATEGORY(cname,desc); \ XBT_LOG_DEFAULT_CATEGORY(cname) /** * \ingroup XBT_log * \param cname name of the cat * \param parent name of the parent * \param desc string describing the purpose of this category * \hideinitializer * * Creates a new subcategory of the parent category and makes it the default * (used by macros that don't explicitly specify a category). */ #define XBT_LOG_NEW_DEFAULT_SUBCATEGORY(cname, parent, desc) \ XBT_LOG_NEW_SUBCATEGORY(cname, parent, desc); \ XBT_LOG_DEFAULT_CATEGORY(cname) /** * \ingroup XBT_log * \param cname name of the cat * \hideinitializer * * Indicates that a category you'll use in this file (to get subcategories of it, * for example) really lives in another file. */ #define XBT_LOG_EXTERNAL_CATEGORY(cname) \ extern s_xbt_log_category_t _XBT_LOGV(cname) /** * \ingroup XBT_log * \param cname name of the cat * \hideinitializer * * Indicates that the default category of this file was declared in another file. */ #define XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(cname) \ XBT_LOG_EXTERNAL_CATEGORY(cname);\ XBT_LOG_DEFAULT_CATEGORY(cname) /* Functions you may call */ XBT_PUBLIC(void) xbt_log_control_set(const char *cs); /* Forward declarations */ typedef struct xbt_log_appender_s s_xbt_log_appender_t, *xbt_log_appender_t; typedef struct xbt_log_layout_s s_xbt_log_layout_t, *xbt_log_layout_t; typedef struct xbt_log_event_s s_xbt_log_event_t, *xbt_log_event_t; typedef struct xbt_log_category_s s_xbt_log_category_t, *xbt_log_category_t; /* * Do NOT access any members of this structure directly. FIXME: move to private? */ struct xbt_log_category_s { xbt_log_category_t parent; xbt_log_category_t firstChild; xbt_log_category_t nextSibling; const char *name; const char *description; int initialized; int threshold; int isThreshInherited; xbt_log_appender_t appender; xbt_log_layout_t layout; int additivity; }; struct xbt_log_event_s { xbt_log_category_t cat; e_xbt_log_priority_t priority; const char *fileName; const char *functionName; int lineNum; va_list ap; char *buffer; int buffer_size; }; /** * \ingroup XBT_log_implem * \param cat the category (not only its name, but the variable) * \param thresholdPriority the priority * * Programatically alters a category's threshold priority (don't use). */ XBT_PUBLIC(void) xbt_log_threshold_set(xbt_log_category_t cat, e_xbt_log_priority_t thresholdPriority); /** * \ingroup XBT_log_implem * \param cat the category (not only its name, but the variable) * \param app the appender * * Programatically sets the category's appender. * (the prefered interface is throught xbt_log_control_set()) * */ XBT_PUBLIC(void) xbt_log_appender_set(xbt_log_category_t cat, xbt_log_appender_t app); /** * \ingroup XBT_log_implem * \param cat the category (not only its name, but the variable) * \param lay the layout * * Programatically sets the category's layout. * (the prefered interface is throught xbt_log_control_set()) * */ XBT_PUBLIC(void) xbt_log_layout_set(xbt_log_category_t cat, xbt_log_layout_t lay); /** * \ingroup XBT_log_implem * \param cat the category (not only its name, but the variable) * \param additivity whether logging actions must be passed to parent. * * Programatically sets whether the logging actions must be passed to * the parent category. * (the prefered interface is throught xbt_log_control_set()) * */ XBT_PUBLIC(void) xbt_log_additivity_set(xbt_log_category_t cat, int additivity); /** @brief create a new simple layout * * This layout is not as flexible as the pattern one */ XBT_PUBLIC(xbt_log_layout_t) xbt_log_layout_simple_new(char *arg); XBT_PUBLIC(xbt_log_layout_t) xbt_log_layout_format_new(char *arg); XBT_PUBLIC(xbt_log_appender_t) xbt_log_appender_file_new(char *arg); /* ********************************** */ /* Functions that you shouldn't call */ /* ********************************** */ XBT_PUBLIC(void) _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...) _XBT_GNUC_PRINTF(2, 3); XBT_PUBLIC(int) _xbt_log_cat_init(xbt_log_category_t category, e_xbt_log_priority_t priority); XBT_PUBLIC_DATA(s_xbt_log_category_t) _XBT_LOGV(XBT_LOG_ROOT_CAT); extern xbt_log_appender_t xbt_log_default_appender; extern xbt_log_layout_t xbt_log_default_layout; /* ********************** */ /* Public functions again */ /* ********************** */ /** * \ingroup XBT_log * \param catName name of the category * \param priority minimal priority to be enabled to return true (must be #e_xbt_log_priority_t) * \hideinitializer * * Returns true if the given priority is enabled for the category. * If you have expensive expressions that are computed outside of the log * command and used only within it, you should make its evaluation conditional * using this macro. */ #define XBT_LOG_ISENABLED(catName, priority) \ _XBT_LOG_ISENABLEDV(_XBT_LOGV(catName), priority) /* * Helper function that implements XBT_LOG_ISENABLED. * * NOTES * First part is a compile-time constant. * Call to xbt_log_cat_init only happens once. */ #define _XBT_LOG_ISENABLEDV(catv, priority) \ (priority >= XBT_LOG_STATIC_THRESHOLD \ && (catv.initialized || _xbt_log_cat_init(&catv, priority)) \ && priority >= catv.threshold) /* * Internal Macros * Some kludge macros to ease maintenance. See how they're used below. * * IMPLEMENTATION NOTE: To reduce the parameter passing overhead of an enabled * message, the many parameters passed to the logging function are packed in a * structure. Since these values will be usually be passed to at least 3 * functions, this is a win. * It also allows adding new values (such as a timestamp) without breaking * code. * Setting the LogEvent's valist member is done inside _log_logEvent. */ /* Logging Macros */ #ifdef XBT_LOG_MAYDAY # define XBT_CLOG(cat, prio, ...) \ _XBT_IF_ONE_ARG(_XBT_CLOG_ARG1, _XBT_CLOG_ARGN, __VA_ARGS__)(__VA_ARGS__) # define _XBT_CLOG_ARG1(f) \ fprintf(stderr,"%s:%d:\n" f, __FILE__, __LINE__) # define _XBT_CLOG_ARGN(f, ...) \ fprintf(stderr,"%s:%d:\n" f, __FILE__, __LINE__, __VA_ARGS__) # define XBT_LOG(...) XBT_CLOG(0, __VA_ARGS__) #else # define XBT_CLOG_(catv, prio, ...) \ do { \ if (_XBT_LOG_ISENABLEDV(catv, prio)) { \ s_xbt_log_event_t _log_ev; \ _log_ev.cat = &(catv); \ _log_ev.priority = (prio); \ _log_ev.fileName = __FILE__; \ _log_ev.functionName = _XBT_FUNCTION; \ _log_ev.lineNum = __LINE__; \ _xbt_log_event_log(&_log_ev, __VA_ARGS__); \ } \ } while (0) # define XBT_CLOG(cat, prio, ...) XBT_CLOG_(_XBT_LOGV(cat), prio, __VA_ARGS__) # define XBT_LOG(...) XBT_CLOG_((*_XBT_LOGV(default)), __VA_ARGS__) #endif /** @ingroup XBT_log * @hideinitializer * \param c the category on which to log * \param ... the format string and its arguments * @brief Log an event at the DEBUG priority on the specified category with these args. */ #define XBT_CDEBUG(c, ...) XBT_CLOG(c, xbt_log_priority_debug, __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log an event at the VERB priority on the specified category with these args. */ #define XBT_CVERB(c, ...) XBT_CLOG(c, xbt_log_priority_verbose, __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log an event at the INFO priority on the specified category with these args. */ #define XBT_CINFO(c, ...) XBT_CLOG(c, xbt_log_priority_info, __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log an event at the WARN priority on the specified category with these args. */ #define XBT_CWARN(c, ...) XBT_CLOG(c, xbt_log_priority_warning, __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log an event at the ERROR priority on the specified category with these args. */ #define XBT_CERROR(c, ...) XBT_CLOG(c, xbt_log_priority_error, __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log an event at the CRITICAL priority on the specified category with these args (CCRITICALn exists for any n<10). */ #define XBT_CCRITICAL(c, ...) XBT_CLOG(c, xbt_log_priority_critical, __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * \param ... the format string and its arguments * @brief Log an event at the DEBUG priority on the default category with these args. */ #define XBT_DEBUG(...) XBT_LOG(xbt_log_priority_debug, __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log an event at the VERB priority on the default category with these args. */ #define XBT_VERB(...) XBT_LOG(xbt_log_priority_verbose, __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log an event at the INFO priority on the default category with these args. */ #define XBT_INFO(...) XBT_LOG(xbt_log_priority_info, __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log an event at the WARN priority on the default category with these args. */ #define XBT_WARN(...) XBT_LOG(xbt_log_priority_warning, __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log an event at the ERROR priority on the default category with these args. */ #define XBT_ERROR(...) XBT_LOG(xbt_log_priority_error, __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log an event at the CRITICAL priority on the default category with these args. */ #define XBT_CRITICAL(...) XBT_LOG(xbt_log_priority_critical, __VA_ARGS__) #define _XBT_IN_OUT(...) \ _XBT_IF_ONE_ARG(_XBT_IN_OUT_ARG1, _XBT_IN_OUT_ARGN, __VA_ARGS__)(__VA_ARGS__) #define _XBT_IN_OUT_ARG1(fmt) \ XBT_LOG(xbt_log_priority_trace, fmt, _XBT_FUNCTION) #define _XBT_IN_OUT_ARGN(fmt, ...) \ XBT_LOG(xbt_log_priority_trace, fmt, _XBT_FUNCTION, __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log at TRACE priority that we entered in current function, appending a user specified format. */ #define XBT_IN(...) _XBT_IN_OUT(">> begin of %s" __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log at TRACE priority that we exited the current function, appending a user specified format. */ #define XBT_OUT(...) _XBT_IN_OUT("<< end of %s" __VA_ARGS__) /** @ingroup XBT_log * @hideinitializer * @brief Log at TRACE priority a message indicating that we reached that point, appending a user specified format. */ #define XBT_HERE(...) XBT_LOG(xbt_log_priority_trace, "-- was here" __VA_ARGS__) #ifdef XBT_USE_DEPRECATED /* Kept for backward compatibility. */ #define CLOG0(...) XBT_CLOG(__VA_ARGS__) #define CLOG1(...) XBT_CLOG(__VA_ARGS__) #define CLOG2(...) XBT_CLOG(__VA_ARGS__) #define CLOG3(...) XBT_CLOG(__VA_ARGS__) #define CLOG4(...) XBT_CLOG(__VA_ARGS__) #define CLOG5(...) XBT_CLOG(__VA_ARGS__) #define CLOG6(...) XBT_CLOG(__VA_ARGS__) #define CLOG7(...) XBT_CLOG(__VA_ARGS__) #define CLOG8(...) XBT_CLOG(__VA_ARGS__) #define CLOG9(...) XBT_CLOG(__VA_ARGS__) #define CLOG10(...) XBT_CLOG(__VA_ARGS__) #define CDEBUG0(...) XBT_CDEBUG(__VA_ARGS__) #define CDEBUG1(...) XBT_CDEBUG(__VA_ARGS__) #define CDEBUG2(...) XBT_CDEBUG(__VA_ARGS__) #define CDEBUG3(...) XBT_CDEBUG(__VA_ARGS__) #define CDEBUG4(...) XBT_CDEBUG(__VA_ARGS__) #define CDEBUG5(...) XBT_CDEBUG(__VA_ARGS__) #define CDEBUG6(...) XBT_CDEBUG(__VA_ARGS__) #define CDEBUG7(...) XBT_CDEBUG(__VA_ARGS__) #define CDEBUG8(...) XBT_CDEBUG(__VA_ARGS__) #define CDEBUG9(...) XBT_CDEBUG(__VA_ARGS__) #define CDEBUG10(...) XBT_CDEBUG(__VA_ARGS__) #define CVERB0(...) XBT_CVERB(__VA_ARGS__) #define CVERB1(...) XBT_CVERB(__VA_ARGS__) #define CVERB2(...) XBT_CVERB(__VA_ARGS__) #define CVERB3(...) XBT_CVERB(__VA_ARGS__) #define CVERB4(...) XBT_CVERB(__VA_ARGS__) #define CVERB5(...) XBT_CVERB(__VA_ARGS__) #define CVERB6(...) XBT_CVERB(__VA_ARGS__) #define CVERB7(...) XBT_CVERB(__VA_ARGS__) #define CVERB8(...) XBT_CVERB(__VA_ARGS__) #define CVERB9(...) XBT_CVERB(__VA_ARGS__) #define CVERB10(...) XBT_CVERB(__VA_ARGS__) #define CINFO0(...) XBT_CINFO(__VA_ARGS__) #define CINFO1(...) XBT_CINFO(__VA_ARGS__) #define CINFO2(...) XBT_CINFO(__VA_ARGS__) #define CINFO3(...) XBT_CINFO(__VA_ARGS__) #define CINFO4(...) XBT_CINFO(__VA_ARGS__) #define CINFO5(...) XBT_CINFO(__VA_ARGS__) #define CINFO6(...) XBT_CINFO(__VA_ARGS__) #define CINFO7(...) XBT_CINFO(__VA_ARGS__) #define CINFO8(...) XBT_CINFO(__VA_ARGS__) #define CINFO9(...) XBT_CINFO(__VA_ARGS__) #define CINFO10(...) XBT_CINFO(__VA_ARGS__) #define CWARN0(...) XBT_CWARN(__VA_ARGS__) #define CWARN1(...) XBT_CWARN(__VA_ARGS__) #define CWARN2(...) XBT_CWARN(__VA_ARGS__) #define CWARN3(...) XBT_CWARN(__VA_ARGS__) #define CWARN4(...) XBT_CWARN(__VA_ARGS__) #define CWARN5(...) XBT_CWARN(__VA_ARGS__) #define CWARN6(...) XBT_CWARN(__VA_ARGS__) #define CWARN7(...) XBT_CWARN(__VA_ARGS__) #define CWARN8(...) XBT_CWARN(__VA_ARGS__) #define CWARN9(...) XBT_CWARN(__VA_ARGS__) #define CWARN10(...) XBT_CWARN(__VA_ARGS__) #define CERROR0(...) XBT_CERROR(__VA_ARGS__) #define CERROR1(...) XBT_CERROR(__VA_ARGS__) #define CERROR2(...) XBT_CERROR(__VA_ARGS__) #define CERROR3(...) XBT_CERROR(__VA_ARGS__) #define CERROR4(...) XBT_CERROR(__VA_ARGS__) #define CERROR5(...) XBT_CERROR(__VA_ARGS__) #define CERROR6(...) XBT_CERROR(__VA_ARGS__) #define CERROR7(...) XBT_CERROR(__VA_ARGS__) #define CERROR8(...) XBT_CERROR(__VA_ARGS__) #define CERROR9(...) XBT_CERROR(__VA_ARGS__) #define CERROR10(...) XBT_CERROR(__VA_ARGS__) #define CCRITICAL0(...) XBT_CCRITICAL(__VA_ARGS__) #define CCRITICAL1(...) XBT_CCRITICAL(__VA_ARGS__) #define CCRITICAL2(...) XBT_CCRITICAL(__VA_ARGS__) #define CCRITICAL3(...) XBT_CCRITICAL(__VA_ARGS__) #define CCRITICAL4(...) XBT_CCRITICAL(__VA_ARGS__) #define CCRITICAL5(...) XBT_CCRITICAL(__VA_ARGS__) #define CCRITICAL6(...) XBT_CCRITICAL(__VA_ARGS__) #define CCRITICAL7(...) XBT_CCRITICAL(__VA_ARGS__) #define CCRITICAL8(...) XBT_CCRITICAL(__VA_ARGS__) #define CCRITICAL9(...) XBT_CCRITICAL(__VA_ARGS__) #define CCRITICAL10(...) XBT_CCRITICAL(__VA_ARGS__) #define LOG0(...) XBT_LOG(__VA_ARGS__) #define LOG1(...) XBT_LOG(__VA_ARGS__) #define LOG2(...) XBT_LOG(__VA_ARGS__) #define LOG3(...) XBT_LOG(__VA_ARGS__) #define LOG4(...) XBT_LOG(__VA_ARGS__) #define LOG5(...) XBT_LOG(__VA_ARGS__) #define LOG6(...) XBT_LOG(__VA_ARGS__) #define LOG7(...) XBT_LOG(__VA_ARGS__) #define LOG8(...) XBT_LOG(__VA_ARGS__) #define LOG9(...) XBT_LOG(__VA_ARGS__) #define LOG10(...) XBT_LOG(__VA_ARGS__) #define DEBUG0(...) XBT_DEBUG(__VA_ARGS__) #define DEBUG1(...) XBT_DEBUG(__VA_ARGS__) #define DEBUG2(...) XBT_DEBUG(__VA_ARGS__) #define DEBUG3(...) XBT_DEBUG(__VA_ARGS__) #define DEBUG4(...) XBT_DEBUG(__VA_ARGS__) #define DEBUG5(...) XBT_DEBUG(__VA_ARGS__) #define DEBUG6(...) XBT_DEBUG(__VA_ARGS__) #define DEBUG7(...) XBT_DEBUG(__VA_ARGS__) #define DEBUG8(...) XBT_DEBUG(__VA_ARGS__) #define DEBUG9(...) XBT_DEBUG(__VA_ARGS__) #define DEBUG10(...) XBT_DEBUG(__VA_ARGS__) #define VERB0(...) XBT_VERB(__VA_ARGS__) #define VERB1(...) XBT_VERB(__VA_ARGS__) #define VERB2(...) XBT_VERB(__VA_ARGS__) #define VERB3(...) XBT_VERB(__VA_ARGS__) #define VERB4(...) XBT_VERB(__VA_ARGS__) #define VERB5(...) XBT_VERB(__VA_ARGS__) #define VERB6(...) XBT_VERB(__VA_ARGS__) #define VERB7(...) XBT_VERB(__VA_ARGS__) #define VERB8(...) XBT_VERB(__VA_ARGS__) #define VERB9(...) XBT_VERB(__VA_ARGS__) #define VERB10(...) XBT_VERB(__VA_ARGS__) #define INFO0(...) XBT_INFO(__VA_ARGS__) #define INFO1(...) XBT_INFO(__VA_ARGS__) #define INFO2(...) XBT_INFO(__VA_ARGS__) #define INFO3(...) XBT_INFO(__VA_ARGS__) #define INFO4(...) XBT_INFO(__VA_ARGS__) #define INFO5(...) XBT_INFO(__VA_ARGS__) #define INFO6(...) XBT_INFO(__VA_ARGS__) #define INFO7(...) XBT_INFO(__VA_ARGS__) #define INFO8(...) XBT_INFO(__VA_ARGS__) #define INFO9(...) XBT_INFO(__VA_ARGS__) #define INFO10(...) XBT_INFO(__VA_ARGS__) #define WARN0(...) XBT_WARN(__VA_ARGS__) #define WARN1(...) XBT_WARN(__VA_ARGS__) #define WARN2(...) XBT_WARN(__VA_ARGS__) #define WARN3(...) XBT_WARN(__VA_ARGS__) #define WARN4(...) XBT_WARN(__VA_ARGS__) #define WARN5(...) XBT_WARN(__VA_ARGS__) #define WARN6(...) XBT_WARN(__VA_ARGS__) #define WARN7(...) XBT_WARN(__VA_ARGS__) #define WARN8(...) XBT_WARN(__VA_ARGS__) #define WARN9(...) XBT_WARN(__VA_ARGS__) #define WARN10(...) XBT_WARN(__VA_ARGS__) #define ERROR0(...) XBT_ERROR(__VA_ARGS__) #define ERROR1(...) XBT_ERROR(__VA_ARGS__) #define ERROR2(...) XBT_ERROR(__VA_ARGS__) #define ERROR3(...) XBT_ERROR(__VA_ARGS__) #define ERROR4(...) XBT_ERROR(__VA_ARGS__) #define ERROR5(...) XBT_ERROR(__VA_ARGS__) #define ERROR6(...) XBT_ERROR(__VA_ARGS__) #define ERROR7(...) XBT_ERROR(__VA_ARGS__) #define ERROR8(...) XBT_ERROR(__VA_ARGS__) #define ERROR9(...) XBT_ERROR(__VA_ARGS__) #define ERROR10(...) XBT_ERROR(__VA_ARGS__) #define CRITICAL0(...) XBT_CRITICAL(__VA_ARGS__) #define CRITICAL1(...) XBT_CRITICAL(__VA_ARGS__) #define CRITICAL2(...) XBT_CRITICAL(__VA_ARGS__) #define CRITICAL3(...) XBT_CRITICAL(__VA_ARGS__) #define CRITICAL4(...) XBT_CRITICAL(__VA_ARGS__) #define CRITICAL5(...) XBT_CRITICAL(__VA_ARGS__) #define CRITICAL6(...) XBT_CRITICAL(__VA_ARGS__) #define CRITICAL7(...) XBT_CRITICAL(__VA_ARGS__) #define CRITICAL8(...) XBT_CRITICAL(__VA_ARGS__) #define CRITICAL9(...) XBT_CRITICAL(__VA_ARGS__) #define CRITICAL10(...) XBT_CRITICAL(__VA_ARGS__) #define XBT_IN1(...) XBT_IN(__VA_ARGS__); #define XBT_IN2(...) XBT_IN(__VA_ARGS__); #define XBT_IN3(...) XBT_IN(__VA_ARGS__); #define XBT_IN4(...) XBT_IN(__VA_ARGS__); #define XBT_IN5(...) XBT_IN(__VA_ARGS__); #define XBT_IN6(...) XBT_IN(__VA_ARGS__); #endif SG_END_DECL() #endif /* ! _XBT_LOG_H_ */ SimGrid-3.11/include/xbt/ex.h000644 001750 001750 00000053753 12342443646 015056 0ustar00cici000000 000000 /* ex - Exception Handling */ /* Copyright (c) 2005-2014. The SimGrid Team. * All rights reserved. */ /* Copyright (c) 2002-2004 Ralf S. Engelschall */ /* Copyright (c) 2002-2004 The OSSP Project */ /* Copyright (c) 2002-2004 Cable & Wireless */ /* All rights reserved. */ /* This code is inspirated from the OSSP version (as retrieved back in 2004)*/ /* It was heavily modified to fit the SimGrid framework. */ /* The OSSP version has the following copyright notice: ** OSSP ex - Exception Handling ** Copyright (c) 2002-2004 Ralf S. Engelschall ** Copyright (c) 2002-2004 The OSSP Project ** Copyright (c) 2002-2004 Cable & Wireless ** ** This file is part of OSSP ex, an exception handling library ** which can be found at http://www.ossp.org/pkg/lib/ex/. ** ** Permission to use, copy, modify, and distribute this software for ** any purpose with or without fee is hereby granted, provided that ** the above copyright notice and this permission notice appear in all ** copies. ** ** THIS SOFTWARE IS PROVIDED `AS IS'' AND ANY EXPRESSED OR IMPLIED ** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF ** MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ** IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR ** CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF ** USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT ** OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ** SUCH DAMAGE. */ /* The extensions made for the SimGrid project can either be distributed */ /* under the same license, or under the LGPL v2.1 */ #ifndef __XBT_EX_H__ #define __XBT_EX_H__ #include "xbt/sysdep.h" #include "xbt/misc.h" #include "xbt/virtu.h" SG_BEGIN_DECL() /*-*-* Emergency debuging: define this when the exceptions get crazy *-*-*/ #undef __EX_MAYDAY #ifdef __EX_MAYDAY # include #include # define MAYDAY_SAVE(m) printf("%d %s:%d save %p\n", \ xbt_getpid(), __FILE__, __LINE__, \ (m)->jb \ ), # define MAYDAY_RESTORE(m) printf("%d %s:%d restore %p\n", \ xbt_getpid(), __FILE__, __LINE__, \ (m)->jb \ ), # define MAYDAY_CATCH(e) printf("%d %s:%d Catched '%s'\n", \ xbt_getpid(), __FILE__, __LINE__, \ (e).msg \ ), #else # define MAYDAY_SAVE(m) # define MAYDAY_RESTORE(m) # define MAYDAY_CATCH(e) #endif /*-*-* end of debugging stuff *-*-*/ #if defined(__EX_MCTX_MCSC__) #include /* POSIX.1 ucontext(3) */ #define __ex_mctx_struct ucontext_t uc; #define __ex_mctx_save(mctx) (getcontext(&(mctx)->uc) == 0) #define __ex_mctx_restored(mctx) /* noop */ #define __ex_mctx_restore(mctx) (void)setcontext(&(mctx)->uc) #elif defined(__EX_MCTX_SSJLJ__) #include /* POSIX.1 sigjmp_buf(3) */ #define __ex_mctx_struct sigjmp_buf jb; #define __ex_mctx_save(mctx) (sigsetjmp((mctx)->jb, 1) == 0) #define __ex_mctx_restored(mctx) /* noop */ #define __ex_mctx_restore(mctx) (void)siglongjmp((mctx)->jb, 1) #elif defined(__EX_MCTX_SJLJ__) || !defined(__EX_MCTX_CUSTOM__) || defined(__EX_MAYDAY) #include /* ISO-C jmp_buf(3) */ #define __ex_mctx_struct jmp_buf jb; #define __ex_mctx_save(mctx) ( MAYDAY_SAVE(mctx) setjmp((mctx)->jb) == 0) #define __ex_mctx_restored(mctx) /* noop */ #define __ex_mctx_restore(mctx) ( MAYDAY_RESTORE(mctx) (void)longjmp((mctx)->jb, 1)) #endif /* declare the machine context type */ typedef struct { __ex_mctx_struct} __ex_mctx_t; /** @addtogroup XBT_ex * @brief A set of macros providing exception a la C++ in ANSI C (grounding feature) * * This module is a small ISO-C++ style exception handling library * for use in the ISO-C language. It allows you to use the paradigm * of throwing and catching exceptions in order to reduce the amount * of error handling code without hindering program robustness. * * This is achieved by directly transferring exceptional return codes * (and the program control flow) from the location where the exception * is raised (throw point) to the location where it is handled (catch * point) -- usually from a deeply nested sub-routine to a parent * routine. All intermediate routines no longer have to make sure that * the exceptional return codes from sub-routines are correctly passed * back to the parent. * * These features are brought to you by a modified version of the libex * library, one of the numerous masterpiece of Ralf S. Engelschall. * * \htmlonly
\endhtmlonly * * @section XBT_ex_toc TABLE OF CONTENTS * * - \ref XBT_ex_intro * - \ref XBT_ex_base * - \ref XBT_ex_pitfalls * * \htmlonly
\endhtmlonly * * @section XBT_ex_intro DESCRIPTION * * In SimGrid, an exception is a triple <\a msg , \a category , \a value> * where \a msg is a human-readable text describing the exceptional * condition, \a code an integer describing what went wrong and \a value * providing a sort of sub-category. (this is different in the original libex). * * @section XBT_ex_base BASIC USAGE * * \em TRY \b TRIED_BLOCK [\em TRY_CLEANUP \b CLEANUP_BLOCK] \em CATCH (variable) \b CATCH_BLOCK * * This is the primary syntactical construct provided. It is modeled after the * ISO-C++ try-catch clause and should sound familiar to most of you. * * Any exception thrown directly from the TRIED_BLOCK block or from called * subroutines is caught. Cleanups which must be done after this block * (whenever an exception arose or not) should be placed into the optionnal * CLEANUP_BLOCK. The code dealing with the exceptions when they arise should * be placed into the (mandatory) CATCH_BLOCK. * * * In absence of exception, the control flow goes into the blocks TRIED_BLOCK * and CLEANUP_BLOCK (if present); The CATCH_BLOCK block is then ignored. * * When an exception is thrown, the control flow goes through the following * blocks: TRIED_BLOCK (up to the statement throwing the exception), * CLEANUP_BLOCK (if any) and CATCH_BLOCK. The exception is stored in a * variable for inspection inside the CATCH_BLOCK. This variable must be * declared in the outter scope, but its value is only valid within the * CATCH_BLOCK block. * * Some notes: * - TRY, CLEANUP and CATCH cannot be used separately, they work * only in combination and form a language clause as a whole. * - In contrast to the syntax of other languages (such as C++ or Jave) there * is only one CATCH block and not multiple ones (all exceptions are * of the same \em xbt_ex_t C type). * - the variable of CATCH can naturally be reused in subsequent * CATCH clauses. * - it is possible to nest TRY clauses. * * The TRY block is a regular ISO-C language statement block, but * *
it is not * allowed to jump into it via "goto" or longjmp(3) or out of it via "break", * "return", "goto" or longjmp(3).
* * This is because there is some hidden setup and * cleanup that needs to be done regardless of whether an exception is * caught. Bypassing these steps will break the exception handling facility. * The symptom are likely to be a segfault at the next exception raising point, * ie far away from the point where you did the mistake. If you suspect * that kind of error in your code, have a look at the little script * tools/xbt_exception_checker in the CVS. It extracts all the TRY * blocks from a set of C files you give it and display them (and only * them) on the standard output. You can then grep for the forbidden * keywords on that output. * * The CLEANUP and CATCH blocks are regular ISO-C language statement * blocks without any restrictions. You are even allowed to throw (and, in the * CATCH block, to re-throw) exceptions. * * There is one subtle detail you should remember about TRY blocks: * Variables used in the CLEANUP or CATCH clauses must be declared with * the storage class "volatile", otherwise they might contain outdated * information if an exception is thrown. * * * This is because you usually do not know which commands in the TRY * were already successful before the exception was thrown (logically speaking) * and because the underlying ISO-C setjmp(3) facility applies those * restrictions (technically speaking). As a matter of fact, value changes * between the TRY and the THROW may be discarded if you forget the * "volatile" keyword. * * \section XBT_ex_pitfalls PROGRAMMING PITFALLS * * Exception handling is a very elegant and efficient way of dealing with * exceptional situation. Nevertheless it requires additional discipline in * programming and there are a few pitfalls one must be aware of. Look the * following code which shows some pitfalls and contains many errors (assuming * a mallocex() function which throws an exception if malloc(3) fails): * * \dontinclude ex.c * \skip BAD_EXAMPLE * \until end_of_bad_example * * This example raises a few issues: * -# \b variable \b scope \n * Variables which are used in the CLEANUP or CATCH clauses must be * declared before the TRY clause, otherwise they only exist inside the * TRY block. In the example above, cp1, cp2 and cp3 only exist in the * TRY block and are invisible from the CLEANUP and CATCH * blocks. * -# \b variable \b initialization \n * Variables which are used in the CLEANUP or CATCH clauses must * be initialized before the point of the first possible THROW is * reached. In the example above, CLEANUP would have trouble using cp3 * if mallocex() throws a exception when allocating a TOOBIG buffer. * -# \b volatile \b variable \n * Variables which are used in the CLEANUP or CATCH clauses MUST BE * DECLARED AS "volatile", otherwise they might contain outdated * information when an exception is thrown. * -# \b clean \b before \b catch \n * The CLEANUP clause is not only place before the CATCH clause in * the source code, it also occures before in the control flow. So, * resources being cleaned up cannot be used in the CATCH block. In the * example, c3 gets freed before the printf placed in CATCH. * -# \b variable \b uninitialization \n * If resources are passed out of the scope of the * TRY/CLEANUP/CATCH construct, they naturally shouldn't get * cleaned up. The example above does free(3) cp1 in CLEANUP although * its value was affected to globalcontext->first, invalidating this * pointer. * The following is fixed version of the code (annotated with the pitfall items * for reference): * * \skip GOOD_EXAMPLE * \until end_of_good_example * * @{ */ /** @brief different kind of errors */ typedef enum { unknown_error = 0, /**< unknown error */ arg_error, /**< Invalid argument */ bound_error, /**< Out of bounds argument */ mismatch_error, /**< The provided ID does not match */ not_found_error, /**< The searched element was not found */ system_error, /**< a syscall did fail */ network_error, /**< error while sending/receiving data */ timeout_error, /**< not quick enough, dude */ cancel_error, /**< an action was canceled */ thread_error, /**< error while [un]locking */ host_error, /**< host failed */ tracing_error, /**< error during the simulation tracing */ io_error, /**< disk or file error */ vm_error /**< vm error */ } xbt_errcat_t; XBT_PUBLIC(const char *) xbt_ex_catname(xbt_errcat_t cat); /** @brief Structure describing an exception */ typedef struct { char *msg; /**< human readable message */ xbt_errcat_t category; /**< category like HTTP (what went wrong) */ int value; /**< like errno (why did it went wrong) */ /* throw point */ char *procname; /**< Name of the process who thrown this */ int pid; /**< PID of the process who thrown this */ char *file; /**< Thrown point */ int line; /**< Thrown point */ char *func; /**< Thrown point */ /* Backtrace */ int used; char **bt_strings; /* only filed on display (or before the network propagation) */ void *bt[XBT_BACKTRACE_SIZE]; } xbt_ex_t; /* declare the running context type * (that's where we get the process name for the logs and the exception storage) * -- do not mess with it -- */ typedef struct { __ex_mctx_t *ctx_mctx; /* permanent machine context of enclosing try/catch */ int ctx_caught; /* temporary flag whether exception was caught */ volatile xbt_ex_t exception; /* temporary exception storage */ } xbt_running_ctx_t; /* the static and dynamic initializers for a context structure */ #define XBT_RUNNING_CTX_INITIALIZER \ { NULL, 0, { /* content */ NULL, unknown_error, 0, \ /* throw point*/ NULL, 0, NULL, 0, NULL, \ /* backtrace */ 0, NULL, /* bt[] */ } } XBT_PUBLIC_DATA(const xbt_running_ctx_t) __xbt_ex_ctx_initializer; #define XBT_RUNNING_CTX_INITIALIZE(ctx) (*(ctx) = __xbt_ex_ctx_initializer) /* the exception context */ typedef xbt_running_ctx_t *(*xbt_running_ctx_fetcher_t) (void); XBT_PUBLIC_DATA(xbt_running_ctx_fetcher_t) __xbt_running_ctx_fetch; XBT_PUBLIC( xbt_running_ctx_t *)__xbt_ex_ctx_default(void); /* the termination handler */ typedef void (*ex_term_cb_t) (xbt_ex_t *); XBT_PUBLIC_DATA(ex_term_cb_t) __xbt_ex_terminate; XBT_PUBLIC( void )__xbt_ex_terminate_default(xbt_ex_t * e); /** @brief Introduce a block where exception may be dealed with * @hideinitializer */ #define TRY \ { \ xbt_running_ctx_t *__xbt_ex_ctx_ptr = __xbt_running_ctx_fetch(); \ int __ex_cleanup = 0; \ __ex_mctx_t *__ex_mctx_en; \ __ex_mctx_t __ex_mctx_me; \ __ex_mctx_en = __xbt_ex_ctx_ptr->ctx_mctx; \ __xbt_ex_ctx_ptr->ctx_mctx = &__ex_mctx_me; \ if (__ex_mctx_save(&__ex_mctx_me)) { \ if (1) /** @brief optional(!) block for cleanup * @hideinitializer */ #define TRY_CLEANUP \ else { \ } \ __xbt_ex_ctx_ptr->ctx_caught = 0; \ } else { \ __ex_mctx_restored(&__ex_mctx_me); \ __xbt_ex_ctx_ptr->ctx_caught = 1; \ } \ __xbt_ex_ctx_ptr->ctx_mctx = __ex_mctx_en; \ __ex_cleanup = 1; \ if (1) { \ if (1) #ifndef DOXYGEN_SKIP # ifdef __cplusplus # define XBT_EX_T_CPLUSPLUSCAST (xbt_ex_t&) # else # define XBT_EX_T_CPLUSPLUSCAST # endif #endif /** @brief the block for catching (ie, deal with) an exception * @hideinitializer */ #define CATCH(e) \ DO_CATCH((e) = XBT_EX_T_CPLUSPLUSCAST __xbt_running_ctx_fetch()->exception) /** @brief like CATCH(e) but without argument * @hideinitializer * * Useful if you only want to rethrow the exception caught, and do not want to * bother with an unused variable. */ #define CATCH_ANONYMOUS DO_CATCH(0) #define DO_CATCH(_xbt_do_catch_set_e) \ else { \ } \ if (!(__ex_cleanup)) \ __xbt_ex_ctx_ptr->ctx_caught = 0; \ } else { \ if (!(__ex_cleanup)) { \ __ex_mctx_restored(&__ex_mctx_me); \ __xbt_ex_ctx_ptr->ctx_caught = 1; \ } \ } \ __xbt_ex_ctx_ptr->ctx_mctx = __ex_mctx_en; \ } \ if ( !(__xbt_running_ctx_fetch()->ctx_caught) \ || ((void)(_xbt_do_catch_set_e), \ MAYDAY_CATCH(__xbt_running_ctx_fetch()->exception) 0)) { \ } \ else #define DO_THROW(running_ctx) \ do { /* deal with the exception */ \ xbt_running_ctx_t *ctx = (running_ctx); \ if (ctx->ctx_mctx == NULL) \ __xbt_ex_terminate((xbt_ex_t*)&(ctx->exception)); /* not catched */ \ else \ __ex_mctx_restore(ctx->ctx_mctx); /* catched somewhere */ \ abort(); /* nope, stupid GCC, we won't survive a THROW */ \ /* (this won't be reached) */ \ } while(0) /** @brief Helper macro for THROW and THROWF * @hideinitializer * * @param _throw_ctx: the throwing context in which we should construct the exception * @param c: category code (integer) * @param v: value (integer) * @param m: message text * * If called from within a TRY/CATCH construct, this exception * is copied into the CATCH relevant variable program control flow * is derouted to the CATCH (after the optional sg_cleanup). * * If no TRY/CATCH construct embeds this call, the program calls * abort(3). * * The THROW can be performed everywhere, including inside TRY, * CLEANUP and CATCH blocks. */ #define THROW_PREPARE(_throw_ctx, c, v, m) \ /* build the exception */ \ _throw_ctx->exception.msg = (m); \ _throw_ctx->exception.category = (xbt_errcat_t)(c); \ _throw_ctx->exception.value = (v); \ _throw_ctx->exception.procname = (char*)xbt_procname(); \ _throw_ctx->exception.pid = xbt_getpid(); \ _throw_ctx->exception.file = (char*)__FILE__; \ _throw_ctx->exception.line = __LINE__; \ _throw_ctx->exception.func = (char*)_XBT_FUNCTION; \ _throw_ctx->exception.bt_strings = NULL; \ xbt_backtrace_current((xbt_ex_t *)&(_throw_ctx->exception)); #define _THROW(c, v, m) \ do { /* change this sequence into one block */ \ xbt_running_ctx_t *_throw_ctx = __xbt_running_ctx_fetch(); \ THROW_PREPARE(_throw_ctx, c, v, m); \ DO_THROW(_throw_ctx); \ } while (0) /** @brief Builds and throws an exception @hideinitializer */ #define THROW(c, v) _THROW(c, v, NULL) /** @brief Builds and throws an exception with a printf-like formatted message @hideinitializer */ #define THROWF(c, v, ...) _THROW(c, v, bprintf(__VA_ARGS__)) #define THROW_IMPOSSIBLE \ THROWF(unknown_error, 0, "The Impossible Did Happen (yet again)") #define THROW_UNIMPLEMENTED \ THROWF(unknown_error, 0, "Function %s unimplemented",_XBT_FUNCTION) #define DIE_IMPOSSIBLE xbt_die("The Impossible Did Happen (yet again)") /** @brief re-throwing of an already caught exception (ie, pass it to the upper catch block) * @hideinitializer */ #define RETHROW DO_THROW(__xbt_running_ctx_fetch()) /** @brief like THROWF, but adding some details to the message of an existing exception * @hideinitializer */ #define RETHROWF(...) \ do { \ char *_xbt_ex_internal_msg = __xbt_running_ctx_fetch()->exception.msg; \ __xbt_running_ctx_fetch()->exception.msg = bprintf(__VA_ARGS__, \ _xbt_ex_internal_msg); \ free(_xbt_ex_internal_msg); \ RETHROW; \ } while (0) /** @brief Exception destructor */ XBT_PUBLIC(void) xbt_ex_free(xbt_ex_t e); /** @brief Shows a backtrace of the current location */ XBT_PUBLIC(void) xbt_backtrace_display_current(void); /** @brief reimplementation of glibc backtrace based directly on gcc library, without implicit malloc */ XBT_PUBLIC(int) xbt_backtrace_no_malloc(void**bt, int size); /** @brief Captures a backtrace for further use */ XBT_PUBLIC(void) xbt_backtrace_current(xbt_ex_t * e); /** @brief Display a previously captured backtrace */ XBT_PUBLIC(void) xbt_backtrace_display(xbt_ex_t * e); /** @brief Get current backtrace with libunwind */ XBT_PUBLIC(int) xbt_libunwind_backtrace(void *bt[XBT_BACKTRACE_SIZE], int size); #ifdef XBT_USE_DEPRECATED /* Kept for backward compatibility. */ #define THROW0(c, v, m) \ do { if (m) THROWF(c, v, m); else THROW(c, v); } while (0) #define THROW1(c, v, ...) THROWF(c, v, __VA_ARGS__) #define THROW2(c, v, ...) THROWF(c, v, __VA_ARGS__) #define THROW3(c, v, ...) THROWF(c, v, __VA_ARGS__) #define THROW4(c, v, ...) THROWF(c, v, __VA_ARGS__) #define THROW5(c, v, ...) THROWF(c, v, __VA_ARGS__) #define THROW6(c, v, ...) THROWF(c, v, __VA_ARGS__) #define THROW7(c, v, ...) THROWF(c, v, __VA_ARGS__) #define RETHROW0(...) RETHROWF(__VA_ARGS__) #define RETHROW1(...) RETHROWF(__VA_ARGS__) #define RETHROW2(...) RETHROWF(__VA_ARGS__) #define RETHROW3(...) RETHROWF(__VA_ARGS__) #define RETHROW4(...) RETHROWF(__VA_ARGS__) #define RETHROW5(...) RETHROWF(__VA_ARGS__) #endif SG_END_DECL() /** @} */ #endif /* __XBT_EX_H__ */ SimGrid-3.11/include/xbt/parmap.h000644 001750 001750 00000004263 12342443646 015712 0ustar00cici000000 000000 /* A thread pool. */ /* Copyright (c) 2007, 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_PARMAP_H #define _XBT_PARMAP_H #include "xbt/misc.h" /* SG_BEGIN_DECL */ #include "xbt/function_types.h" #include "xbt/dynar.h" SG_BEGIN_DECL() /** \addtogroup XBT_parmap * \ingroup XBT_misc * \brief Parallel map. * * A function is applied to all elements of a dynar in parallel with n worker * threads. * The worker threads are persistent until the destruction of the parmap. * * If there are more than n elements in the dynar, the worker threads are * allowed to fetch themselves remaining work with xbt_parmap_next() and * execute it. * * \{ */ /** \brief Parallel map data type (opaque type) */ typedef struct s_xbt_parmap *xbt_parmap_t; /** * \brief Synchronization mode of the worker threads of a parmap. */ typedef enum { XBT_PARMAP_POSIX, /**< use POSIX synchronization primitives */ XBT_PARMAP_FUTEX, /**< use Linux futex system call */ XBT_PARMAP_BUSY_WAIT, /**< busy waits (no system calls, maximum CPU usage) */ XBT_PARMAP_DEFAULT /**< futex if available, posix otherwise */ } e_xbt_parmap_mode_t; XBT_PUBLIC(xbt_parmap_t) xbt_parmap_new(unsigned int num_workers, e_xbt_parmap_mode_t mode); XBT_PUBLIC(void) xbt_parmap_destroy(xbt_parmap_t parmap); XBT_PUBLIC(void) xbt_parmap_apply(xbt_parmap_t parmap, void_f_pvoid_t fun, xbt_dynar_t data); XBT_PUBLIC(void*) xbt_parmap_next(xbt_parmap_t parmap); #ifdef HAVE_MC XBT_PUBLIC(xbt_parmap_t) xbt_parmap_mc_new(unsigned int num_workers, e_xbt_parmap_mode_t mode); XBT_PUBLIC(int) xbt_parmap_mc_apply(xbt_parmap_t parmap, int_f_pvoid_pvoid_t fun, void *data, unsigned int length, void* ref_snapshot); #endif /** \} */ SG_END_DECL() #endif SimGrid-3.11/include/xbt/mmalloc.h000644 001750 001750 00000005477 12342443646 016066 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /* Copyright (C) 1991, 1992 Free Software Foundation, Inc. This file was then part of the GNU C Library. */ #ifndef MMALLOC_H #define MMALLOC_H 1 #include #ifdef HAVE_MMALLOC #ifdef HAVE_STDDEF_H # include #else # include /* for size_t */ # include /* for NULL */ #endif #include "xbt/dynar.h" #include "xbt/dict.h" /* Datatype representing a separate heap. The whole point of the mmalloc module * is to allow several such heaps in the process. It thus works by redefining * all the classical memory management functions (malloc and friends) with an * extra first argument: the heap in which the memory is to be taken. * * The heap structure itself is an opaque object that shouldnt be messed with. */ typedef struct mdesc *xbt_mheap_t; /* Allocate SIZE bytes of memory (and memset it to 0). */ XBT_PUBLIC( void ) *mmalloc(xbt_mheap_t md, size_t size); /* Allocate SIZE bytes of memory (and don't mess with it) */ void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size); /* Re-allocate the previously allocated block in void*, making the new block SIZE bytes long. */ XBT_PUBLIC( void ) *mrealloc(xbt_mheap_t md, void *ptr, size_t size); /* Free a block allocated by `mmalloc', `mrealloc' or `mcalloc'. */ XBT_PUBLIC( void ) mfree(xbt_mheap_t md, void *ptr); XBT_PUBLIC( xbt_mheap_t ) xbt_mheap_new(int fd, void *baseaddr); XBT_PUBLIC( void ) xbt_mheap_destroy_no_free(xbt_mheap_t md); XBT_PUBLIC( void ) *xbt_mheap_destroy(xbt_mheap_t md); /* return the heap used when NULL is passed as first argument to any mm* function */ XBT_PUBLIC( xbt_mheap_t ) mmalloc_get_default_md(void); /* To change the heap used when using the legacy version malloc/free/realloc and such */ void mmalloc_set_current_heap(xbt_mheap_t new_heap); xbt_mheap_t mmalloc_get_current_heap(void); struct s_mc_snapshot; struct s_dw_type; int mmalloc_compare_heap(struct s_mc_snapshot* snapshot1, struct s_mc_snapshot* snapshot2, xbt_mheap_t heap1, xbt_mheap_t heap2); int mmalloc_linear_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2); int init_heap_information(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dynar_t to_ignore1, xbt_dynar_t to_ignore2); int compare_heap_area(void *area1, void* area2, struct s_mc_snapshot* snapshot1, struct s_mc_snapshot* snapshot2, xbt_dynar_t previous, struct s_dw_type *type, int pointer_level); void reset_heap_information(void); size_t mmalloc_get_bytes_used(xbt_mheap_t); ssize_t mmalloc_get_busy_size(xbt_mheap_t, void *ptr); #endif #endif /* MMALLOC_H */ SimGrid-3.11/include/xbt/misc.h000644 001750 001750 00000020730 12342443646 015362 0ustar00cici000000 000000 /* xbt.h - Public interface to the xbt (simgrid's toolbox) */ /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef XBT_MISC_H #define XBT_MISC_H /* Define _GNU_SOURCE for getline, isfinite, etc. */ #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif /* Attributes are only in recent versions of GCC */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)) # define _XBT_GNUC_PRINTF( format_idx, arg_idx ) \ __attribute__((__format__ (__printf__, format_idx, arg_idx))) # define _XBT_GNUC_SCANF( format_idx, arg_idx ) \ __attribute__((__format__ (__scanf__, format_idx, arg_idx))) # define _XBT_GNUC_NORETURN __attribute__((__noreturn__)) # define _XBT_GNUC_UNUSED __attribute__((__unused__)) /* Constructor priorities exist since gcc 4.3. Apparently, they are however not * supported on Macs. */ # if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && !defined(__APPLE__) # define _XBT_GNUC_CONSTRUCTOR(prio) __attribute__((__constructor__ (prio))) # define _XBT_GNUC_DESTRUCTOR(prio) __attribute__((__destructor__ (prio))) # else # define _XBT_GNUC_CONSTRUCTOR(prio) __attribute__((__constructor__)) # define _XBT_GNUC_DESTRUCTOR(prio) __attribute__((__destructor__)) # endif # undef _XBT_NEED_INIT_PRAGMA #else /* !__GNUC__ */ # define _XBT_GNUC_PRINTF( format_idx, arg_idx ) # define _XBT_GNUC_SCANF( format_idx, arg_idx ) # define _XBT_GNUC_NORETURN # define _XBT_GNUC_UNUSED # define _XBT_GNUC_CONSTRUCTOR(prio) # define _XBT_GNUC_DESTRUCTOR(prio) # define _XBT_NEED_INIT_PRAGMA 1 #endif /* !__GNUC__ */ /* inline and __FUNCTION__ are only in GCC when -ansi is off */ #if defined(__GNUC__) && ! defined(__STRICT_ANSI__) # define _XBT_FUNCTION __FUNCTION__ #elif (defined(__STDC__) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) # define _XBT_FUNCTION __func__ /* ISO-C99 compliant */ #else # define _XBT_FUNCTION "function" #endif #ifdef DOXYGEN # define XBT_INLINE #else # ifndef __cplusplus # if defined(__GNUC__) && ! defined(__STRICT_ANSI__) # define XBT_INLINE inline # elif (defined(__STDC__) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) # define XBT_INLINE inline # elif defined(__BORLANDC__) && !defined(__STRICT_ANSI__) # define XBT_INLINE __inline # else # define XBT_INLINE # endif # else # if defined (__VISUALC__) # define XBT_INLINE __inline # else # define XBT_INLINE inline # endif # endif /* __cplusplus */ #endif /* improvable on gcc (by evaluating arguments only once), but wouldn't be portable */ #ifdef MIN # undef MIN #endif #define MIN(a,b) ((a)<(b)?(a):(b)) #ifdef MAX # undef MAX #endif #define MAX(a,b) ((a)>(b)?(a):(b)) /* * Expands to `one' if there is only one argument for the variadic part. * Otherwise, expands to `more'. * Works with up to 63 arguments, which is the maximum mandated by the C99 * standard. */ #define _XBT_IF_ONE_ARG(one, more, ...) \ _XBT_IF_ONE_ARG_(__VA_ARGS__, \ more, more, more, more, more, more, more, more, \ more, more, more, more, more, more, more, more, \ more, more, more, more, more, more, more, more, \ more, more, more, more, more, more, more, more, \ more, more, more, more, more, more, more, more, \ more, more, more, more, more, more, more, more, \ more, more, more, more, more, more, more, more, \ more, more, more, more, more, more, more, one) #define _XBT_IF_ONE_ARG_(a64, a63, a62, a61, a60, a59, a58, a57, \ a56, a55, a54, a53, a52, a51, a50, a49, \ a48, a47, a46, a45, a44, a43, a42, a41, \ a40, a39, a38, a37, a36, a35, a34, a33, \ a32, a31, a30, a29, a28, a27, a26, a25, \ a24, a23, a22, a21, a20, a19, a18, a17, \ a16, a15, a14, a13, a12, a11, a10, a9, \ a8, a7, a6, a5, a4, a3, a2, a1, N, ...) N /* * Function calling convention (not used for now) */ #ifdef _XBT_WIN32 # ifndef _XBT_CALL # define _XBT_CALL __cdecl # endif #else # define _XBT_CALL #endif /* Handle import/export stuff * * Rational of XBT_PUBLIC: * * This is for library symbols visible from the application-land. * Basically, any symbols defined in the include/directory must be * like this (plus some other globals). * * UNIX coders should just think of it as a special way to say "extern". * * * If you build the DLL, define the DLL_EXPORT symbol so that all symbols * actually get exported by this file. * * If you do a static windows compilation, define DLL_STATIC, both when * compiling the application files and when compiling the library. * * * If you link your application against the DLL or if you do a UNIX build, * don't do anything special. This file will do the right thing for you * by default. * * * Rational of XBT_EXPORT_NO_IMPORT: (windows-only cruft) * * Symbols which must be exported in the DLL, but not imported from it. * * * This is obviously useful for initialized globals (which cannot be * extern or similar). * * This is also used in the log mecanism where a macro creates the * variable automatically. When the macro is called from within SimGrid, * the symbol must be exported, but when called from within the client * code, it must not try to retrieve the symbol from the DLL since it's * not in there. * * Rational of XBT_IMPORT_NO_EXPORT: (windows-only cruft) * * Symbols which must be imported from the DLL, but not explicitely * exported from it. * * * The root log category is already exported, but not imported explicitely * when creating a subcategory since we cannot import the parent category * to deal with the fact that the parent may be in application space, not * DLL space. */ /* Build the DLL */ #if defined(DLL_EXPORT) # define XBT_PUBLIC(type) extern __declspec(dllexport) type # define XBT_EXPORT_NO_IMPORT(type) __declspec(dllexport) type # define XBT_IMPORT_NO_EXPORT(type) type # define XBT_PUBLIC_DATA(type) extern __declspec(dllexport) type # define XBT_PUBLIC_CLASS class __declspec(dllexport) /* Pack everything up statically */ #elif defined(DLL_STATIC) # define XBT_PUBLIC(type) extern type # define XBT_EXPORT_NO_IMPORT(type) type # define XBT_IMPORT_NO_EXPORT(type) type # define XBT_PUBLIC_DATA(type) extern type # define XBT_PUBLIC_CLASS class /* Link against the DLL */ #elif (defined(_XBT_WIN32) && !defined(DLL_EXPORT) && !defined(DLL_STATIC)) # define XBT_PUBLIC(type) extern __declspec(dllimport) type # define XBT_EXPORT_NO_IMPORT(type) type # define XBT_IMPORT_NO_EXPORT(type) __declspec(dllimport) type # define XBT_PUBLIC_DATA(type) extern __declspec(dllimport) type # define XBT_PUBLIC_CLASS class __declspec(dllimport) /* UNIX build */ #else # define XBT_PUBLIC(type) extern type # define XBT_EXPORT_NO_IMPORT(type) type # define XBT_IMPORT_NO_EXPORT(type) type # define XBT_PUBLIC_DATA(type) extern type # define XBT_PUBLIC_CLASS class #endif #if !defined (max) && !defined(__cplusplus) # define max(a,b) (((a) > (b)) ? (a) : (b)) #endif #if !defined (min) && !defined(__cplusplus) # define min(a,b) (((a) < (b)) ? (a) : (b)) #endif #define TRUE 1 #define FALSE 0 /*! C++ users need love */ #ifndef SG_BEGIN_DECL # ifdef __cplusplus # define SG_BEGIN_DECL() extern "C" { # else # define SG_BEGIN_DECL() # endif #endif #ifndef SG_END_DECL # ifdef __cplusplus # define SG_END_DECL() } # else # define SG_END_DECL() # endif #endif /* End of cruft for C++ */ SG_BEGIN_DECL() /** Cache the size of a memory page for the current system. */ XBT_PUBLIC_DATA(int) xbt_pagesize; XBT_PUBLIC(const char *) xbt_procname(void); #define XBT_BACKTRACE_SIZE 10 /* FIXME: better place? Do document */ SG_END_DECL() #endif /* XBT_MISC_H */ SimGrid-3.11/include/xbt/cunit.h000644 001750 001750 00000021056 12342443646 015553 0ustar00cici000000 000000 /* cunit - A little C Unit facility */ /* Copyright (c) 2005-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /* This is partially inspirated from the OSSP ts (Test Suite Library) */ #ifndef _XBT_CUNIT_H_ #define _XBT_CUNIT_H_ #include "xbt/sysdep.h" /* XBT_GNU_PRINTF */ #include "xbt/ex.h" SG_BEGIN_DECL() /* note that the internals of testall, that follow, are not publicly documented */ /* test suite object type */ typedef struct s_xbt_test_suite *xbt_test_suite_t; /* test object type */ typedef struct s_xbt_test_unit *xbt_test_unit_t; /* test callback function type */ typedef void (*ts_test_cb_t) (void); /* test suite operations */ XBT_PUBLIC(xbt_test_suite_t) xbt_test_suite_new(const char *name, const char *fmt, ...); XBT_PUBLIC(xbt_test_suite_t) xbt_test_suite_by_name(const char *name, const char *fmt, ...); XBT_PUBLIC(void) xbt_test_suite_dump(xbt_test_suite_t suite); XBT_PUBLIC(void) xbt_test_suite_push(xbt_test_suite_t suite, const char *name, ts_test_cb_t func, const char *fmt, ...); /* Run all the specified tests. what_to_do allows to disable some tests. * It is a coma (,) separated list of directives. They are applied from left to right. * * Each of them of form: * * [-|+]suitename[:unitname[:testname]] * * * First char: * if it's a '-', the directive disables something * if it's a '+', the directive enables something * By default, everything is enabled, but you can disable a suite and reenable some parts * * Suitename: the suite on which the directive acts * * unitname: if given, the unit on which the directive acts. If not, acts on any units. * * testname: if given, the test on which the directive acts. If not, acts on any tests. */ XBT_PUBLIC(int) xbt_test_run(char *selection, int verbosity); /* Show information about the selection of tests */ XBT_PUBLIC(void) xbt_test_dump(char *selection); /* Cleanup the mess */ XBT_PUBLIC(void) xbt_test_exit(void); /** * @addtogroup XBT_cunit * @brief Unit test mechanism (to test a set of functions) * * This module is mainly intended to allow the tests of SimGrid * itself and may lack the level of genericity that you would expect * as a user. Only use it in external projects at your own risk (but * it work rather well for us). We play with the idea of migrating * to an external solution for our unit tests, possibly offering * more features, but having absolutely no dependencies is a nice * feature of SimGrid (and this code is sufficient to cover our * needs, actually, so why should we bother switching?) * * Note that if you want to test a full binary (such as an example), * you want to use our integration testing mechanism, not our unit * testing one. Please refer to Section \ref * inside_cmake_addtest_integration * * Some more information on our unit testing is available in Section @ref inside_cmake_addtest_unit. * * All code intended to be executed as a unit test will be extracted * by a script (tools/sg_unit_extract.pl), and must thus be protected * between preprocessor definitions, as follows. Note that * SIMGRID_TEST string must appear on the endif line too for the * script to work, and that this script does not allow to have more * than one suite per file. For now, but patches are naturally * welcome. * @verbatim #ifdef SIMGRID_TEST #endif // SIMGRID_TEST @endverbatim * * * @{ */ /** @brief Provide informations about the suite declared in this file * @hideinitializer * * Actually, this macro is not used by C, but by the script * extracting the test units, but that should be transparent for you. * * @param suite_name the short name of this suite, to be used in the --tests argument of testall afterward. Avoid spaces and any other strange chars * @param suite_title instructive title that testall should display when your suite is run */ #define XBT_TEST_SUITE(suite_name,suite_title) /** @brief Declare a new test units (containing individual tests) * @hideinitializer * * @param name the short name that will be used in test all to enable/disable this test * @param func a valid function name that will be used to contain all code of this unit * @param title human informative description of your test (displayed in testall) */ #define XBT_TEST_UNIT(name,func,title) \ void func(void); /*prototype*/ \ void func(void) /* test operations */ XBT_PUBLIC(void) _xbt_test_add(const char *file, int line, const char *fmt, ...) _XBT_GNUC_PRINTF(3, 4); XBT_PUBLIC(void) _xbt_test_fail(const char *file, int line, const char *fmt, ...) _XBT_GNUC_PRINTF(3, 4); XBT_PUBLIC(void) _xbt_test_log(const char *file, int line, const char *fmt, ...) _XBT_GNUC_PRINTF(3, 4); /** @brief Declare that a new test begins (printf-like parameters, describing the test) * @hideinitializer */ #define xbt_test_add(...) _xbt_test_add(__FILE__, __LINE__, __VA_ARGS__) /** @brief Declare that the lastly started test failed (printf-like parameters, describing failure cause) * @hideinitializer */ #define xbt_test_fail(...) _xbt_test_fail(__FILE__, __LINE__, __VA_ARGS__) /** @brief The lastly started test is actually an assert * @hideinitializer * * - If provided a uniq parameter, this is assumed to be a condition that is expected to be true * - If provided more parameters, the first one is a condition, and the other ones are printf-like arguments that are to be displayed when the condition fails. */ #define xbt_test_assert(...) _XBT_IF_ONE_ARG(_xbt_test_assert_ARG1, \ _xbt_test_assert_ARGN, \ __VA_ARGS__)(__VA_ARGS__) #define _xbt_test_assert_ARG1(cond) _xbt_test_assert_CHECK(cond, \ "%s", #cond) #define _xbt_test_assert_ARGN(cond, ...) _xbt_test_assert_CHECK(cond, \ __VA_ARGS__) #define _xbt_test_assert_CHECK(cond, ...) \ do { if (!(cond)) xbt_test_fail(__VA_ARGS__); } while (0) #define xbt_test_log(...) _xbt_test_log(__FILE__, __LINE__, __VA_ARGS__) /** @brief Declare that the lastly started test failed because of the provided exception */ XBT_PUBLIC(void) xbt_test_exception(xbt_ex_t e); /** @brief Declare that the lastly started test was expected to fail (and actually failed) */ XBT_PUBLIC(void) xbt_test_expect_failure(void); /** @brief Declare that the lastly started test should be skiped today */ XBT_PUBLIC(void) xbt_test_skip(void); /** @} */ #ifdef XBT_USE_DEPRECATED /* Kept for backward compatibility. */ #define xbt_test_add0(...) xbt_test_add(__VA_ARGS__) #define xbt_test_add1(...) xbt_test_add(__VA_ARGS__) #define xbt_test_add2(...) xbt_test_add(__VA_ARGS__) #define xbt_test_add3(...) xbt_test_add(__VA_ARGS__) #define xbt_test_add4(...) xbt_test_add(__VA_ARGS__) #define xbt_test_add5(...) xbt_test_add(__VA_ARGS__) #define xbt_test_fail0(...) xbt_test_fail(__VA_ARGS__) #define xbt_test_fail1(...) xbt_test_fail(__VA_ARGS__) #define xbt_test_fail2(...) xbt_test_fail(__VA_ARGS__) #define xbt_test_fail3(...) xbt_test_fail(__VA_ARGS__) #define xbt_test_fail4(...) xbt_test_fail(__VA_ARGS__) #define xbt_test_fail5(...) xbt_test_fail(__VA_ARGS__) #define xbt_test_assert0(...) xbt_test_assert(__VA_ARGS__) #define xbt_test_assert1(...) xbt_test_assert(__VA_ARGS__) #define xbt_test_assert2(...) xbt_test_assert(__VA_ARGS__) #define xbt_test_assert3(...) xbt_test_assert(__VA_ARGS__) #define xbt_test_assert4(...) xbt_test_assert(__VA_ARGS__) #define xbt_test_assert5(...) xbt_test_assert(__VA_ARGS__) #define xbt_test_log0(...) xbt_test_log(__VA_ARGS__) #define xbt_test_log1(...) xbt_test_log(__VA_ARGS__) #define xbt_test_log2(...) xbt_test_log(__VA_ARGS__) #define xbt_test_log3(...) xbt_test_log(__VA_ARGS__) #define xbt_test_log4(...) xbt_test_log(__VA_ARGS__) #define xbt_test_log5(...) xbt_test_log(__VA_ARGS__) #endif SG_END_DECL() #endif /* _TS_H_ */ SimGrid-3.11/include/xbt/graph.h000644 001750 001750 00000016122 12342443646 015530 0ustar00cici000000 000000 /* Copyright (c) 2006-2007, 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_GRAPH_H #define _XBT_GRAPH_H #include "xbt/misc.h" /* SG_BEGIN_DECL */ #include "xbt/dynar.h" SG_BEGIN_DECL() /** @addtogroup XBT_graph * @brief A graph data type with several interesting algorithms * * @{ */ typedef struct xbt_node *xbt_node_t; typedef struct xbt_edge *xbt_edge_t; typedef struct xbt_graph *xbt_graph_t; /* Node structure */ /* Be carfull of what you do with this structure */ /* typedef struct xbt_node *xbt_node_t; */ typedef struct xbt_node { xbt_dynar_t out; xbt_dynar_t in; /* not used when the graph is directed */ double position_x; /* positive value: negative means undefined */ double position_y; /* positive value: negative means undefined */ void *data; /* user data */ void *xbtdata; /* private xbt data: should be reinitialized at the beginning of your algorithm if you need to use it */ } s_xbt_node_t; /* edge structure */ /* Be carfull of what you do with this structure */ /* typedef struct xbt_edge *xbt_edge_t; */ typedef struct xbt_edge { xbt_node_t src; xbt_node_t dst; void *data; /* user data */ void *xbtdata; /* private xbt data: should be reinitialized at the beginning of your algorithm if you need to use it */ double length; /* positive value: negative means undefined */ } s_xbt_edge_t; /* Graph structure */ /* Be carfull of what you do with this structure */ /* typedef struct xbt_graph *xbt_graph_t; */ typedef struct xbt_graph { xbt_dynar_t nodes; xbt_dynar_t edges; unsigned short int directed; void *data; /* user data */ void *xbtdata; /* private xbt data: should be reinitialized at the beginning of your algorithm if you need to use it */ } s_xbt_graph_t; /* API */ XBT_PUBLIC(xbt_graph_t) xbt_graph_new_graph(unsigned short int directed, void *data); XBT_PUBLIC(xbt_node_t) xbt_graph_new_node(xbt_graph_t g, void *data); XBT_PUBLIC(xbt_edge_t) xbt_graph_new_edge(xbt_graph_t g, xbt_node_t src, xbt_node_t dst, void *data); XBT_PUBLIC(void *) xbt_graph_node_get_data(xbt_node_t node); XBT_PUBLIC(void) xbt_graph_node_set_data(xbt_node_t node, void *data); XBT_PUBLIC(void *) xbt_graph_edge_get_data(xbt_edge_t edge); XBT_PUBLIC(void) xbt_graph_edge_set_data(xbt_edge_t edge, void *data); XBT_PUBLIC(xbt_edge_t) xbt_graph_get_edge(xbt_graph_t g, xbt_node_t src, xbt_node_t dst); XBT_PUBLIC(void) xbt_graph_edge_set_length(xbt_edge_t e, double length); XBT_PUBLIC(double) xbt_graph_edge_get_length(xbt_edge_t e); XBT_PUBLIC(double *) xbt_graph_get_length_matrix(xbt_graph_t g); XBT_PUBLIC(void) xbt_graph_free_node(xbt_graph_t g, xbt_node_t n, void_f_pvoid_t node_free_function, void_f_pvoid_t edge_free_function); XBT_PUBLIC(void) xbt_graph_free_edge(xbt_graph_t g, xbt_edge_t e, void_f_pvoid_t free_function); XBT_PUBLIC(void) xbt_graph_free_graph(xbt_graph_t g, void_f_pvoid_t node_free_function, void_f_pvoid_t edge_free_function, void_f_pvoid_t graph_free_function); XBT_PUBLIC(int) __xbt_find_in_dynar(xbt_dynar_t dynar, void *p); XBT_PUBLIC(xbt_dynar_t) xbt_graph_get_nodes(xbt_graph_t g); XBT_PUBLIC(xbt_dynar_t) xbt_graph_get_edges(xbt_graph_t g); XBT_PUBLIC(xbt_dynar_t) xbt_graph_node_get_outedges(xbt_node_t n); XBT_PUBLIC(xbt_node_t) xbt_graph_edge_get_source(xbt_edge_t e); XBT_PUBLIC(xbt_node_t) xbt_graph_edge_get_target(xbt_edge_t e); XBT_PUBLIC(xbt_graph_t) xbt_graph_read(const char *filename, void *(node_label_and_data) (xbt_node_t, const char *, const char *), void *(edge_label_and_data) (xbt_edge_t, const char *, const char *) ); XBT_PUBLIC(void) xbt_graph_export_graphviz(xbt_graph_t g, const char *filename, const char *(node_name) (xbt_node_t), const char *(edge_name) (xbt_edge_t)); XBT_PUBLIC(void) xbt_graph_export_graphxml(xbt_graph_t g, const char *filename, const char *(node_name) (xbt_node_t), const char *(edge_name) (xbt_edge_t), const char *(node_data_print) (void *), const char *(edge_data_print) (void *)); XBT_PUBLIC(xbt_graph_t) xbt_graph_load (const char *filename); XBT_PUBLIC(void) xbt_graph_save (xbt_graph_t span, const char *filename, const char *(nname) (xbt_node_t), const char *(ename) (xbt_edge_t)); /* Not implemented yet ! */ /* void *xbt_graph_to_array(xbt_graph_t g); */ XBT_PUBLIC(xbt_node_t *) xbt_graph_shortest_paths(xbt_graph_t g); /** @brief transforms the network structure of a directed acyclic graph given into a linear structure @return: an array containing the nodes of the graph sorted in order reverse to the path of exploration if a cycle is detected an exception is raised */ XBT_PUBLIC(xbt_node_t *) xbt_graph_topo_sort(xbt_graph_t g); XBT_PUBLIC(xbt_edge_t *) xbt_graph_spanning_tree_prim(xbt_graph_t g); /** Convenient for loop : g is a graph, n a node, e an edge, b a bucket and i an item **/ /* #define xbt_graph_foreachInNeighbor(v,n,i) \ */ /* for(i=xbt_fifo_get_first_item((v)->in); \ */ /* ((i)?(n=((xbt_edge_t)((xbt_fifo_get_item_content(i)) */ /* )->src):(NULL));\ */ /* i=xbt_fifo_get_next_item(i)) */ /* #define xbt_graph_foreachOutNeighbor(v,n,i) \ */ /* for(i=xbt_fifo_get_first_item((v)->out); \ */ /* ((i)?(n=((xbt_edge_t)(xbt_fifo_get_item_content(i)))->dst):(NULL));\ */ /* i=xbt_fifo_get_next_item(i)) */ SG_END_DECL() #endif /* _XBT_GRAPH_H */ /** @} */ SimGrid-3.11/include/xbt/virtu.h000644 001750 001750 00000002126 12342443646 015577 0ustar00cici000000 000000 /* virtu - virtualization layer for XBT to choose between GRAS and MSG implementation */ /* Copyright (c) 2007, 2009-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef __XBT_VIRTU_H__ #define __XBT_VIRTU_H__ #include "xbt/misc.h" #include "xbt/sysdep.h" #include "xbt/function_types.h" #include "xbt/dynar.h" SG_BEGIN_DECL() /* Get the PID of the current (simulated) process */ XBT_PUBLIC_DATA(int_f_void_t) xbt_getpid; /* Get the name of the UNIX process englobing the world */ XBT_PUBLIC_DATA(char*) xbt_binary_name; /** Contains all the parameters we got from the command line (including argv[0]) */ XBT_PUBLIC_DATA(xbt_dynar_t) xbt_cmdline; /** * * Time management functions, returns the system time or sleeps a process. */ XBT_PUBLIC(double) xbt_time(void); XBT_PUBLIC(void) xbt_sleep(double sec); SG_END_DECL() #endif /* __XBT_VIRTU_H__ */ SimGrid-3.11/include/xbt/graphxml_parse.h000644 001750 001750 00000003651 12342443646 017446 0ustar00cici000000 000000 /* Copyright (c) 2006-2007, 2009-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_GRAPHXML_PARSE_H #define _XBT_GRAPHXML_PARSE_H #include /* to have FILE */ #include "xbt/misc.h" #include "xbt/graphxml.h" #include "simgrid_config.h" #ifndef YY_TYPEDEF_YY_SIZE_T #define YY_TYPEDEF_YY_SIZE_T typedef size_t yy_size_t; #endif /* Entry-point of the graphxml parser. */ extern int_f_void_t xbt_graph_parse; /* Hook for the different tags. They can be redefined at will whereas the versions without the _fun can't. */ extern void_f_void_t STag_graphxml_graph_fun; extern void_f_void_t ETag_graphxml_graph_fun; extern void_f_void_t STag_graphxml_node_fun; extern void_f_void_t ETag_graphxml_node_fun; extern void_f_void_t STag_graphxml_edge_fun; extern void_f_void_t ETag_graphxml_edge_fun; XBT_PUBLIC(void) xbt_graph_parse_open(const char *file); XBT_PUBLIC(void) xbt_graph_parse_close(void); XBT_PUBLIC(void) xbt_graph_parse_reset_parser(void); XBT_PUBLIC(double) xbt_graph_parse_get_double(const char *string); /* Prototypes of the functions offered by flex */ XBT_PUBLIC(int) xbt_graph_parse_lex(void); XBT_PUBLIC(int) xbt_graph_parse_get_lineno(void); XBT_PUBLIC(FILE *) xbt_graph_parse_get_in(void); XBT_PUBLIC(FILE *) xbt_graph_parse_get_out(void); XBT_PUBLIC(yy_size_t) xbt_graph_parse_get_leng(void); XBT_PUBLIC(char *) xbt_graph_parse_get_text(void); XBT_PUBLIC(void) xbt_graph_parse_set_lineno(int line_number); XBT_PUBLIC(void) xbt_graph_parse_set_in(FILE * in_str); XBT_PUBLIC(void) xbt_graph_parse_set_out(FILE * out_str); XBT_PUBLIC(int) xbt_graph_parse_get_debug(void); XBT_PUBLIC(void) xbt_graph_parse_set_debug(int bdebug); XBT_PUBLIC(int) xbt_graph_parse_lex_destroy(void); #endif SimGrid-3.11/include/xbt/xbt_os_time.h000644 001750 001750 00000003043 12342443646 016741 0ustar00cici000000 000000 /* xbt/xbt_os_timer.h -- system dependency on time functions */ /* Copyright (c) 2007, 2009-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_OS_TIMER_H #define _XBT_OS_TIMER_H #include /* XBT_PUBLIC */ #include /* size_t */ /** @brief get time in seconds * gives the number of seconds since the Epoch (00:00:00 UTC, January 1, 1970). */ XBT_PUBLIC(double) xbt_os_time(void); XBT_PUBLIC(void) xbt_os_sleep(double sec); typedef struct s_xbt_os_timer *xbt_os_timer_t; XBT_PUBLIC(xbt_os_timer_t) xbt_os_timer_new(void); XBT_PUBLIC(void) xbt_os_timer_free(xbt_os_timer_t timer); XBT_PUBLIC(double) xbt_os_timer_elapsed(xbt_os_timer_t timer); XBT_PUBLIC(size_t) xbt_os_timer_size(void); XBT_PUBLIC(void) xbt_os_walltimer_start(xbt_os_timer_t timer); XBT_PUBLIC(void) xbt_os_walltimer_resume(xbt_os_timer_t timer); XBT_PUBLIC(void) xbt_os_walltimer_stop(xbt_os_timer_t timer); XBT_PUBLIC(void) xbt_os_cputimer_start(xbt_os_timer_t timer); XBT_PUBLIC(void) xbt_os_cputimer_resume(xbt_os_timer_t timer); XBT_PUBLIC(void) xbt_os_cputimer_stop(xbt_os_timer_t timer); XBT_PUBLIC(void) xbt_os_threadtimer_start(xbt_os_timer_t timer); XBT_PUBLIC(void) xbt_os_threadtimer_resume(xbt_os_timer_t timer); XBT_PUBLIC(void) xbt_os_threadtimer_stop(xbt_os_timer_t timer); #endif SimGrid-3.11/include/xbt/fifo.h000644 001750 001750 00000007302 12342443646 015352 0ustar00cici000000 000000 /* Copyright (c) 2004-2007, 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_FIFO_H #define _XBT_FIFO_H #include "xbt/misc.h" /* SG_BEGIN_DECL */ #include "xbt/function_types.h" /* int_f_pvoid_pvoid_t */ SG_BEGIN_DECL() /** @addtogroup XBT_fifo * @brief This section describes the API to generic workqueue. * * These functions provide the same kind of functionnality as dynamic arrays but in time O(1). * However these functions use malloc/free way too much often. */ /** @defgroup XBT_fifo_cons Fifo constructor and destructor * @ingroup XBT_fifo * * @{ */ /** \brief Bucket structure */ typedef struct xbt_fifo_item *xbt_fifo_item_t; /** \brief FIFO structure */ typedef struct xbt_fifo *xbt_fifo_t; XBT_PUBLIC(xbt_fifo_t) xbt_fifo_new(void); XBT_PUBLIC(void) xbt_fifo_free(xbt_fifo_t); XBT_PUBLIC(void) xbt_fifo_reset(xbt_fifo_t); /** @} */ /** @defgroup XBT_fifo_perl Fifo perl-like functions * @ingroup XBT_fifo * * @{ */ XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_push(xbt_fifo_t, void *); XBT_PUBLIC(void *) xbt_fifo_pop(xbt_fifo_t); XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_unshift(xbt_fifo_t, void *); XBT_PUBLIC(void *) xbt_fifo_shift(xbt_fifo_t); XBT_PUBLIC(int) xbt_fifo_size(xbt_fifo_t); XBT_PUBLIC(int) xbt_fifo_is_in(xbt_fifo_t, void *); XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_search_item(xbt_fifo_t f, int_f_pvoid_pvoid_t cmp_fun, void *closure); /** @} */ /** @defgroup XBT_fifo_direct Direct access to fifo elements * @ingroup XBT_fifo * * @{ */ XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_new_item(void); XBT_PUBLIC(void) xbt_fifo_set_item_content(xbt_fifo_item_t, void *); XBT_PUBLIC(void *) xbt_fifo_get_item_content(xbt_fifo_item_t); XBT_PUBLIC(void) xbt_fifo_free_item(xbt_fifo_item_t); XBT_PUBLIC(void) xbt_fifo_push_item(xbt_fifo_t, xbt_fifo_item_t); XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_pop_item(xbt_fifo_t); XBT_PUBLIC(void) xbt_fifo_unshift_item(xbt_fifo_t, xbt_fifo_item_t); XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_shift_item(xbt_fifo_t); XBT_PUBLIC(int) xbt_fifo_remove(xbt_fifo_t, void *); XBT_PUBLIC(int) xbt_fifo_remove_all(xbt_fifo_t, void *); XBT_PUBLIC(void) xbt_fifo_remove_item(xbt_fifo_t, xbt_fifo_item_t); XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_get_first_item(xbt_fifo_t l); XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_get_last_item(xbt_fifo_t l); XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_get_next_item(xbt_fifo_item_t i); XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_get_prev_item(xbt_fifo_item_t i); /** * \brief List iterator * asserts and stuff * \param f a list (#xbt_fifo_t) * \param i a bucket (#xbt_fifo_item_t) * \param type a type * \param n an object of type \a type. * @hideinitializer * * Iterates over the whole list. */ #define xbt_fifo_foreach(f,i,n,type) \ for(i=xbt_fifo_get_first_item(f); \ ((i)?(n=(type)(xbt_fifo_get_item_content(i))):(NULL)); \ i=xbt_fifo_get_next_item(i)) /** @} */ /** @defgroup XBT_fifo_misc Misc fifo functions * @ingroup XBT_fifo * * @{ */ XBT_PUBLIC(void **) xbt_fifo_to_array(xbt_fifo_t); XBT_PUBLIC(xbt_fifo_t) xbt_fifo_copy(xbt_fifo_t); /** @} */ /* Deprecated functions: don't use! */ XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_newitem(void); XBT_PUBLIC(void) xbt_fifo_freeitem(xbt_fifo_item_t); XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_getFirstItem(xbt_fifo_t l); XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_getNextItem(xbt_fifo_item_t i); XBT_PUBLIC(xbt_fifo_item_t) xbt_fifo_getPrevItem(xbt_fifo_item_t i); SG_END_DECL() #endif /* _XBT_FIFO_H */ SimGrid-3.11/include/xbt/sysdep.h000644 001750 001750 00000011321 12342443646 015732 0ustar00cici000000 000000 /* xbt/sysdep.h -- all system dependency */ /* no system header should be loaded out of this file so that we have only */ /* one file to check when porting to another OS */ /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_SYSDEP_H #define _XBT_SYSDEP_H #include "xbt/log.h" #include "xbt/misc.h" #include "xbt/asserts.h" #include "simgrid_config.h" #include #include #include /* va_list */ SG_BEGIN_DECL() /* They live in asserts.h, but need to be declared before this module. double declaration to cut dependency cycle */ /** * @addtogroup XBT_error * * @{ */ /** @brief Kill the program in silence */ XBT_PUBLIC(void) xbt_abort(void) _XBT_GNUC_NORETURN; /** * @brief Kill the program with an error message * \param ... a format string and its arguments * * Things are so messed up that the only thing to do now, is to stop the * program. * * The message is handled by a CRITICAL logging request, and may consist of a * format string with arguments. */ #define xbt_die(...) \ do { \ XBT_LOG_EXTERNAL_CATEGORY(xbt); \ XBT_CCRITICAL(xbt, __VA_ARGS__); \ xbt_abort(); \ } while (0) /** @} */ /* these ones live in str.h, but redeclare them here so that we do not need to load the whole str.h and its heavy dependencies */ #ifndef __USE_GNU /* do not redeclare existing headers */ XBT_PUBLIC(int) asprintf(char **ptr, const char *fmt, /*args */ ...) _XBT_GNUC_PRINTF(2, 3); XBT_PUBLIC(int) vasprintf(char **ptr, const char *fmt, va_list ap); #endif XBT_PUBLIC(char *) bprintf(const char *fmt, ...) _XBT_GNUC_PRINTF(1, 2); /** @addtogroup XBT_syscall * @brief Malloc and associated functions, killing the program on error (with \ref XBT_ex) * * @{ */ #if defined(__GNUC__) || defined(DOXYGEN) /** @brief Like strdup, but xbt_die() on error */ static inline __attribute__ ((always_inline)) char *xbt_strdup(const char *s) { char *res = NULL; if (s) { res = strdup(s); if (!res) xbt_die("memory allocation error (strdup returned NULL)"); } return res; } XBT_PUBLIC(void) xbt_backtrace_display_current(void); /** @brief Like malloc, but xbt_die() on error @hideinitializer */ static inline __attribute__ ((always_inline)) void *xbt_malloc(size_t n) { void *res; /* if (n==0) { xbt_backtrace_display_current(); xbt_die("malloc(0) is not portable"); }*/ res = malloc(n); if (!res) xbt_die("Memory allocation of %lu bytes failed", (unsigned long)n); return res; } /** @brief like malloc, but xbt_die() on error and memset data to 0 @hideinitializer */ static inline __attribute__ ((always_inline)) void *xbt_malloc0(size_t n) { void *res; //if (n==0) xbt_die("calloc(0) is not portable"); res = calloc(n, 1); if (!res) xbt_die("Memory callocation of %lu bytes failed", (unsigned long)n); return res; } /** @brief like realloc, but xbt_die() on error @hideinitializer */ static inline __attribute__ ((always_inline)) void *xbt_realloc(void *p, size_t s) { void *res = NULL; //if (s==0) xbt_die("realloc(0) is not portable"); if (s) { if (p) { res = realloc(p, s); if (!res) xbt_die("memory (re)allocation of %lu bytes failed", (unsigned long)s); } else { res = xbt_malloc(s); } } else { free(p); } return res; } #else /* non __GNUC__ */ # define xbt_strdup(s) strdup(s) # define xbt_malloc(n) malloc(n) # define xbt_malloc0(n) calloc(n,1) # define xbt_realloc(p,s) realloc(p,s) #endif /* __GNUC__ ? */ /** @brief like free @hideinitializer */ #define xbt_free free /*nothing specific to do here. A poor valgrind replacement? */ /** @brief like free, but you can be sure that it is a function */ XBT_PUBLIC(void) xbt_free_f(void *p); /** @brief should be given a pointer to pointer, and frees the second one */ XBT_PUBLIC(void) xbt_free_ref(void *d); /** @brief like calloc, but xbt_die() on error and don't memset to 0 @hideinitializer */ #define xbt_new(type, count) ((type*)xbt_malloc (sizeof (type) * (count))) /** @brief like calloc, but xbt_die() on error @hideinitializer */ #define xbt_new0(type, count) ((type*)xbt_malloc0 (sizeof (type) * (count))) /** @} */ SG_END_DECL() #endif /* _XBT_SYSDEP_H */ SimGrid-3.11/include/xbt/lib.h000644 001750 001750 00000003141 12342443646 015172 0ustar00cici000000 000000 /* xbt/lib.h - api to a generic library */ /* Copyright (c) 2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_LIB_H #define _XBT_LIB_H #include SG_BEGIN_DECL() typedef struct s_xbt_lib { xbt_dict_t dict; int levels; void_f_pvoid_t *free_f; /* This is actually a table */ } s_xbt_lib_t, *xbt_lib_t; #define xbt_lib_cursor_t xbt_dict_cursor_t XBT_PUBLIC(xbt_lib_t) xbt_lib_new(void); XBT_PUBLIC(void) xbt_lib_free(xbt_lib_t * lib); XBT_PUBLIC(int) xbt_lib_add_level(xbt_lib_t lib, void_f_pvoid_t free_f); XBT_PUBLIC(void) xbt_lib_set(xbt_lib_t lib, const char *name, int level, void *obj); XBT_PUBLIC(void) xbt_lib_unset(xbt_lib_t lib, const char *key, int level, int invoke_callback); XBT_PUBLIC(void *) xbt_lib_get_or_null(xbt_lib_t lib, const char *name, int level); XBT_PUBLIC(xbt_dictelm_t) xbt_lib_get_elm_or_null(xbt_lib_t lib, const char *key); XBT_PUBLIC(void *) xbt_lib_get_level(xbt_dictelm_t elm, int level); XBT_PUBLIC(void) xbt_lib_remove(xbt_lib_t lib, const char *key); #define xbt_lib_length(lib) xbt_dict_length((lib)->dict) /** @def xbt_lib_foreach @hideinitializer */ #define xbt_lib_foreach(lib, cursor, key, data) \ xbt_dict_foreach((lib)->dict, cursor, key, data) SG_END_DECL() #endif /* _XBT_LIB_H */ SimGrid-3.11/include/simgrid/000755 001750 001750 00000000000 12342443646 015115 5ustar00cici000000 000000 SimGrid-3.11/include/simgrid/simix.h000644 001750 001750 00000064327 12342443646 016433 0ustar00cici000000 000000 /* Copyright (c) 2007-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _SIMIX_SIMIX_H #define _SIMIX_SIMIX_H #include "xbt/misc.h" #include "xbt/fifo.h" #include "xbt/dict.h" #include "xbt/function_types.h" #include "xbt/parmap.h" #include "xbt/swag.h" #include "simgrid/platf.h" #include "simgrid/datatypes.h" SG_BEGIN_DECL() /**************************** Scalar Values **********************************/ typedef union u_smx_scalar u_smx_scalar_t; /* ******************************** Host ************************************ */ /** @brief Host datatype @ingroup simix_host_management A location (or host) is any possible place where a process may run. Thus it is represented as a physical resource with computing capabilities, some mailboxes to enable running process to communicate with remote ones, and some private data that can be only accessed by local process. \see m_host_management @{ */ typedef xbt_dictelm_t smx_host_t; typedef struct s_smx_host_priv *smx_host_priv_t; typedef enum { SIMIX_WAITING, SIMIX_READY, SIMIX_RUNNING, SIMIX_DONE, SIMIX_CANCELED, SIMIX_FAILED, SIMIX_SRC_HOST_FAILURE, SIMIX_DST_HOST_FAILURE, SIMIX_SRC_TIMEOUT, SIMIX_DST_TIMEOUT, SIMIX_LINK_FAILURE } e_smx_state_t; /** @} */ typedef struct s_smx_timer* smx_timer_t; /* ******************************** Synchro ************************************ */ /** * \ingroup simix_synchro_management */ typedef struct s_smx_mutex *smx_mutex_t; /** * \ingroup simix_synchro_management */ typedef struct s_smx_cond *smx_cond_t; /** * \ingroup simix_synchro_management */ typedef struct s_smx_sem *smx_sem_t; /********************************** File *************************************/ typedef struct s_smx_file *smx_file_t; /********************************** Storage *************************************/ typedef xbt_dictelm_t smx_storage_t; typedef struct s_smx_storage_priv *smx_storage_priv_t; /********************************** Action *************************************/ typedef struct s_smx_action *smx_action_t; /* FIXME: replace by specialized action handlers */ /* ****************************** Process *********************************** */ /** @brief Process datatype @ingroup simix_process_management A processt may be defined as a code, with some private data, executing in a location. \see m_process_management @{ */ typedef struct s_smx_process *smx_process_t; typedef enum { SMX_EXIT_SUCCESS = 0, SMX_EXIT_FAILURE = 1 } smx_process_exit_status_t; /** @} */ /* * Type of function that creates a process. * The function must accept the following parameters: * void* process: the process created will be stored there * const char *name: a name for the object. It is for user-level information and can be NULL * xbt_main_func_t code: is a function describing the behavior of the process * void *data: data a pointer to any data one may want to attach to the new object. * smx_host_t host: the location where the new process is executed * int argc, char **argv: parameters passed to code * xbt_dict_t pros: properties */ typedef void (*smx_creation_func_t) ( /* process */ smx_process_t*, /* name */ const char*, /* code */ xbt_main_func_t, /* userdata */ void*, /* hostname */ const char*, /* kill_time */ double, /* argc */ int, /* argv */ char**, /* props */ xbt_dict_t, /* auto_restart */ int, /* parent_process */ smx_process_t); /******************************* Networking ***********************************/ /** * \ingroup simix_rdv_management */ typedef struct s_smx_rvpoint *smx_rdv_t; XBT_PUBLIC(void*) SIMIX_comm_get_src_data(smx_action_t action); XBT_PUBLIC(void*) SIMIX_comm_get_dst_data(smx_action_t action); /******************************** Context *************************************/ typedef struct s_smx_context *smx_context_t; typedef struct s_smx_context_factory *smx_context_factory_t; /* Process creation/destruction callbacks */ typedef void (*void_pfn_smxprocess_t) (smx_process_t); /* Process kill */ typedef void (*void_pfn_smxprocess_t_smxprocess_t) (smx_process_t, smx_process_t); /* for auto-restart function */ typedef void (*void_pfn_smxhost_t) (smx_host_t); /* The following function pointer types describe the interface that any context factory should implement */ typedef smx_context_t (*smx_pfn_context_factory_create_context_t)( xbt_main_func_t, int, char **, void_pfn_smxprocess_t, smx_process_t process); typedef int (*smx_pfn_context_factory_finalize_t) (smx_context_factory_t*); typedef void (*smx_pfn_context_free_t) (smx_context_t); typedef void (*smx_pfn_context_start_t) (smx_context_t); typedef void (*smx_pfn_context_stop_t) (smx_context_t); typedef void (*smx_pfn_context_suspend_t) (smx_context_t context); typedef void (*smx_pfn_context_runall_t) (void); typedef smx_context_t (*smx_pfn_context_self_t) (void); typedef smx_process_t (*smx_pfn_context_get_process_t) (smx_context_t context); /* interface of the context factories */ typedef struct s_smx_context_factory { const char *name; smx_pfn_context_factory_create_context_t create_context; smx_pfn_context_factory_finalize_t finalize; smx_pfn_context_free_t free; smx_pfn_context_stop_t stop; smx_pfn_context_suspend_t suspend; smx_pfn_context_runall_t runall; smx_pfn_context_self_t self; smx_pfn_context_get_process_t get_process; } s_smx_context_factory_t; /* Hack: let msg load directly the right factory */ typedef void (*smx_ctx_factory_initializer_t)(smx_context_factory_t*); XBT_PUBLIC(smx_ctx_factory_initializer_t) smx_factory_initializer_to_use; extern char* smx_context_factory_name; extern int smx_context_stack_size; extern int smx_context_stack_size_was_set; extern int smx_context_guard_size; extern int smx_context_guard_size_was_set; /* *********************** */ /* Context type definition */ /* *********************** */ /* the following function pointers types describe the interface that all context concepts must implement */ /* each context type derive from this structure, so they must contain this structure * at their beginning -- OOP in C :/ */ typedef struct s_smx_context { s_xbt_swag_hookup_t hookup; xbt_main_func_t code; void_pfn_smxprocess_t cleanup_func; smx_process_t process; char **argv; int argc; unsigned iwannadie:1; } s_smx_ctx_base_t; /* methods of this class */ XBT_PUBLIC(void) smx_ctx_base_factory_init(smx_context_factory_t *factory); XBT_PUBLIC(int) smx_ctx_base_factory_finalize(smx_context_factory_t *factory); XBT_PUBLIC(smx_context_t) smx_ctx_base_factory_create_context_sized(size_t size, xbt_main_func_t code, int argc, char **argv, void_pfn_smxprocess_t cleanup, smx_process_t process); XBT_PUBLIC(void) smx_ctx_base_free(smx_context_t context); XBT_PUBLIC(void) smx_ctx_base_stop(smx_context_t context); XBT_PUBLIC(smx_context_t) smx_ctx_base_self(void); XBT_PUBLIC(smx_process_t) smx_ctx_base_get_process(smx_context_t context); XBT_PUBLIC(xbt_dynar_t) SIMIX_process_get_runnable(void); XBT_PUBLIC(smx_process_t) SIMIX_process_from_PID(int PID); XBT_PUBLIC(xbt_dynar_t) SIMIX_processes_as_dynar(void); /* parallelism */ XBT_PUBLIC(int) SIMIX_context_is_parallel(void); XBT_PUBLIC(int) SIMIX_context_get_nthreads(void); XBT_PUBLIC(void) SIMIX_context_set_nthreads(int nb_threads); XBT_PUBLIC(int) SIMIX_context_get_parallel_threshold(void); XBT_PUBLIC(void) SIMIX_context_set_parallel_threshold(int threshold); XBT_PUBLIC(e_xbt_parmap_mode_t) SIMIX_context_get_parallel_mode(void); XBT_PUBLIC(void) SIMIX_context_set_parallel_mode(e_xbt_parmap_mode_t mode); /********************************** Global ************************************/ /* Initialization and exit */ XBT_PUBLIC(void) SIMIX_global_init(int *argc, char **argv); XBT_PUBLIC(void) SIMIX_function_register_process_cleanup(void_pfn_smxprocess_t function); XBT_PUBLIC(void) SIMIX_function_register_process_create(smx_creation_func_t function); XBT_PUBLIC(void) SIMIX_function_register_process_kill(void_pfn_smxprocess_t_smxprocess_t function); /* Simulation execution */ XBT_PUBLIC(void) SIMIX_run(void); XBT_PUBLIC(double) SIMIX_get_clock(void); /* Timer functions FIXME: should these be public? */ XBT_PUBLIC(void) SIMIX_timer_set(double date, void *function, void *arg); XBT_PUBLIC(double) SIMIX_timer_next(void); XBT_PUBLIC(void) SIMIX_display_process_status(void); /******************************* Environment **********************************/ XBT_PUBLIC(void) SIMIX_create_environment(const char *file); /******************************** Deployment **********************************/ XBT_PUBLIC(void) SIMIX_function_register(const char *name, xbt_main_func_t code); XBT_PUBLIC(void) SIMIX_function_register_default(xbt_main_func_t code); XBT_PUBLIC(xbt_main_func_t) SIMIX_get_registered_function(const char *name); XBT_PUBLIC(void) SIMIX_init_application(void); XBT_PUBLIC(void) SIMIX_launch_application(const char *file); XBT_PUBLIC(void) SIMIX_process_set_function(const char* process_host, const char *process_function, xbt_dynar_t arguments, double process_start_time, double process_kill_time); /*********************************** Host *************************************/ //XBT_PUBLIC(xbt_dict_t) SIMIX_host_get_dict(u_smx_scalar_t *args); XBT_PUBLIC(smx_host_t) SIMIX_host_get_by_name(const char *name); XBT_PUBLIC(smx_host_t) SIMIX_host_self(void); XBT_PUBLIC(const char*) SIMIX_host_self_get_name(void); XBT_PUBLIC(const char*) SIMIX_host_get_name(smx_host_t host); /* FIXME: make private: only the name of SIMIX_host_self() should be public without request */ XBT_PUBLIC(void) SIMIX_host_on(smx_host_t host); XBT_PUBLIC(void) SIMIX_host_off(smx_host_t host, smx_process_t issuer); XBT_PUBLIC(void) SIMIX_host_self_set_data(void *data); XBT_PUBLIC(void*) SIMIX_host_self_get_data(void); XBT_PUBLIC(xbt_dict_t) SIMIX_host_get_mounted_storage_list(smx_host_t host); /********************************* Process ************************************/ XBT_PUBLIC(int) SIMIX_process_count(void); XBT_PUBLIC(smx_process_t) SIMIX_process_self(void); XBT_PUBLIC(const char*) SIMIX_process_self_get_name(void); XBT_PUBLIC(void) SIMIX_process_self_set_data(smx_process_t self, void *data); XBT_PUBLIC(void*) SIMIX_process_self_get_data(smx_process_t self); XBT_PUBLIC(smx_context_t) SIMIX_process_get_context(smx_process_t); XBT_PUBLIC(void) SIMIX_process_set_context(smx_process_t p,smx_context_t c); XBT_PUBLIC(int) SIMIX_process_has_pending_comms(smx_process_t process); XBT_PUBLIC(void) SIMIX_process_on_exit_runall(smx_process_t process); XBT_PUBLIC(void) SIMIX_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void *data); /****************************** Communication *********************************/ XBT_PUBLIC(void) SIMIX_comm_set_copy_data_callback(void (*callback) (smx_action_t, void*, size_t)); XBT_PUBLIC(void) SIMIX_comm_copy_pointer_callback(smx_action_t comm, void* buff, size_t buff_size); XBT_PUBLIC(void) SIMIX_comm_copy_buffer_callback(smx_action_t comm, void* buff, size_t buff_size); XBT_PUBLIC(smx_action_t) SIMIX_comm_get_send_match(smx_rdv_t rdv, int (*match_fun)(void*, void*), void* data); XBT_PUBLIC(int) SIMIX_comm_has_send_match(smx_rdv_t rdv, int (*match_fun)(void*, void*), void* data); XBT_PUBLIC(int) SIMIX_comm_has_recv_match(smx_rdv_t rdv, int (*match_fun)(void*, void*), void* data); XBT_PUBLIC(void) SIMIX_comm_finish(smx_action_t action); /******************************************************************************/ /* SIMIX simcalls */ /******************************************************************************/ /* These functions are a system call-like interface to the simulation kernel. */ /* They can also be called from maestro's context, and they are thread safe. */ /******************************************************************************/ /******************************* Host simcalls ********************************/ /* TODO use handlers and keep smx_host_t hidden from higher levels */ XBT_PUBLIC(smx_host_t) simcall_host_get_by_name(const char *name); XBT_PUBLIC(const char *) simcall_host_get_name(smx_host_t host); XBT_PUBLIC(xbt_dict_t) simcall_host_get_properties(smx_host_t host); XBT_PUBLIC(void) simcall_host_on(smx_host_t host); XBT_PUBLIC(void) simcall_host_off(smx_host_t host); XBT_PUBLIC(int) simcall_host_get_core(smx_host_t host); XBT_PUBLIC(xbt_swag_t) simcall_host_get_process_list(smx_host_t host); XBT_PUBLIC(double) simcall_host_get_speed(smx_host_t host); XBT_PUBLIC(double) simcall_host_get_available_speed(smx_host_t host); /* Two possible states, 1 - CPU ON and 0 CPU OFF */ XBT_PUBLIC(int) simcall_host_get_state(smx_host_t host); XBT_PUBLIC(void *) simcall_host_get_data(smx_host_t host); XBT_PUBLIC(void) simcall_host_set_data(smx_host_t host, void *data); XBT_PUBLIC(double) simcall_host_get_current_power_peak(smx_host_t host); XBT_PUBLIC(double) simcall_host_get_power_peak_at(smx_host_t host, int pstate_index); XBT_PUBLIC(int) simcall_host_get_nb_pstates(smx_host_t host); XBT_PUBLIC(void) simcall_host_set_power_peak_at(smx_host_t host, int pstate_index); XBT_PUBLIC(double) simcall_host_get_consumed_energy(smx_host_t host); XBT_PUBLIC(smx_action_t) simcall_host_execute(const char *name, smx_host_t host, double computation_amount, double priority, double bound, unsigned long affinity_mask); XBT_PUBLIC(smx_action_t) simcall_host_parallel_execute(const char *name, int host_nb, smx_host_t *host_list, double *computation_amount, double *communication_amount, double amount, double rate); XBT_PUBLIC(void) simcall_host_execution_destroy(smx_action_t execution); XBT_PUBLIC(void) simcall_host_execution_cancel(smx_action_t execution); XBT_PUBLIC(double) simcall_host_execution_get_remains(smx_action_t execution); XBT_PUBLIC(e_smx_state_t) simcall_host_execution_get_state(smx_action_t execution); XBT_PUBLIC(void) simcall_host_execution_set_priority(smx_action_t execution, double priority); XBT_PUBLIC(void) simcall_host_execution_set_bound(smx_action_t execution, double bound); XBT_PUBLIC(void) simcall_host_execution_set_affinity(smx_action_t execution, smx_host_t host, unsigned long mask); XBT_PUBLIC(e_smx_state_t) simcall_host_execution_wait(smx_action_t execution); XBT_PUBLIC(xbt_dict_t) simcall_host_get_mounted_storage_list(smx_host_t host); XBT_PUBLIC(xbt_dynar_t) simcall_host_get_attached_storage_list(smx_host_t host); XBT_PUBLIC(void) simcall_host_get_params(smx_host_t vm, ws_params_t param); XBT_PUBLIC(void) simcall_host_set_params(smx_host_t vm, ws_params_t param); /******************************* VM simcalls ********************************/ // Create the vm_workstation at the SURF level XBT_PUBLIC(void*) simcall_vm_create(const char *name, smx_host_t host); XBT_PUBLIC(int) simcall_vm_get_state(smx_host_t vm); XBT_PUBLIC(void) simcall_vm_start(smx_host_t vm); XBT_PUBLIC(void) simcall_vm_migrate(smx_host_t vm, smx_host_t dst_pm); XBT_PUBLIC(void *) simcall_vm_get_pm(smx_host_t vm); XBT_PUBLIC(void) simcall_vm_set_bound(smx_host_t vm, double bound); XBT_PUBLIC(void) simcall_vm_set_affinity(smx_host_t vm, smx_host_t pm, unsigned long mask); XBT_PUBLIC(void) simcall_vm_resume(smx_host_t vm); XBT_PUBLIC(void) simcall_vm_save(smx_host_t vm); XBT_PUBLIC(void) simcall_vm_restore(smx_host_t vm); XBT_PUBLIC(void) simcall_vm_suspend(smx_host_t vm); XBT_PUBLIC(void) simcall_vm_destroy(smx_host_t vm); XBT_PUBLIC(void) simcall_vm_shutdown(smx_host_t vm); /**************************** Process simcalls ********************************/ /* Constructor and Destructor */ XBT_PUBLIC(void) simcall_process_create(smx_process_t *process, const char *name, xbt_main_func_t code, void *data, const char *hostname, double kill_time, int argc, char **argv, xbt_dict_t properties, int auto_restart); XBT_PUBLIC(void) simcall_process_kill(smx_process_t process); XBT_PUBLIC(void) simcall_process_killall(int reset_pid); /* Process handling */ XBT_PUBLIC(void) simcall_process_cleanup(smx_process_t process); XBT_PUBLIC(void) simcall_process_change_host(smx_process_t process, smx_host_t dest); XBT_PUBLIC(void) simcall_process_suspend(smx_process_t process); XBT_PUBLIC(void) simcall_process_resume(smx_process_t process); /* Getters and Setters */ XBT_PUBLIC(int) simcall_process_count(void); XBT_PUBLIC(void *) simcall_process_get_data(smx_process_t process); XBT_PUBLIC(void) simcall_process_set_data(smx_process_t process, void *data); XBT_PUBLIC(smx_host_t) simcall_process_get_host(smx_process_t process); XBT_PUBLIC(const char *) simcall_process_get_name(smx_process_t process); XBT_PUBLIC(int) simcall_process_get_PID(smx_process_t process); XBT_PUBLIC(int) simcall_process_get_PPID(smx_process_t process); XBT_PUBLIC(int) simcall_process_is_suspended(smx_process_t process); XBT_PUBLIC(xbt_dict_t) simcall_process_get_properties(smx_process_t host); XBT_PUBLIC(void) simcall_process_set_kill_time(smx_process_t process, double kill_time); XBT_PUBLIC(void) simcall_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void *data); XBT_PUBLIC(void) simcall_process_auto_restart_set(smx_process_t process, int auto_restart); XBT_PUBLIC(smx_process_t) simcall_process_restart(smx_process_t process); XBT_PUBLIC(void) simcall_process_join(smx_process_t process, double timeout); /* Sleep control */ XBT_PUBLIC(e_smx_state_t) simcall_process_sleep(double duration); /************************** Comunication simcalls *****************************/ /***** Rendez-vous points *****/ XBT_PUBLIC(smx_rdv_t) simcall_rdv_create(const char *name); XBT_PUBLIC(void) simcall_rdv_destroy(smx_rdv_t rvp); XBT_PUBLIC(smx_rdv_t) simcall_rdv_get_by_name(const char *name); XBT_PUBLIC(int) simcall_rdv_comm_count_by_host(smx_rdv_t rdv, smx_host_t host); XBT_PUBLIC(smx_action_t) simcall_rdv_get_head(smx_rdv_t rdv); XBT_PUBLIC(smx_process_t) simcall_rdv_get_receiver(smx_rdv_t rdv); XBT_PUBLIC(void) simcall_rdv_set_receiver(smx_rdv_t rdv , smx_process_t process); XBT_PUBLIC(xbt_dict_t) SIMIX_get_rdv_points(void); /***** Communication simcalls *****/ XBT_PUBLIC(void) simcall_comm_send(smx_rdv_t rdv, double task_size, double rate, void *src_buff, size_t src_buff_size, int (*match_fun)(void *, void *, smx_action_t), void (*copy_data_fun)(smx_action_t, void*, size_t), void *data, double timeout); XBT_PUBLIC(smx_action_t) simcall_comm_isend(smx_rdv_t rdv, double task_size, double rate, void *src_buff, size_t src_buff_size, int (*match_fun)(void *, void *, smx_action_t), void (*clean_fun)(void *), void (*copy_data_fun)(smx_action_t, void*, size_t), void *data, int detached); XBT_PUBLIC(void) simcall_comm_recv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size, int (*match_fun)(void *, void *, smx_action_t), void (*copy_data_fun)(smx_action_t, void*, size_t), void *data, double timeout, double rate); XBT_PUBLIC(smx_action_t) simcall_comm_irecv(smx_rdv_t rdv, void *dst_buff, size_t * dst_buff_size, int (*match_fun)(void *, void *, smx_action_t), void (*copy_data_fun)(smx_action_t, void*, size_t), void *data, double rate); XBT_PUBLIC(smx_action_t) simcall_comm_iprobe(smx_rdv_t rdv, int src, int tag, int (*match_fun)(void *, void *, smx_action_t), void *data); XBT_PUBLIC(void) simcall_comm_cancel(smx_action_t comm); /* FIXME: waitany is going to be a vararg function, and should take a timeout */ XBT_PUBLIC(unsigned int) simcall_comm_waitany(xbt_dynar_t comms); XBT_PUBLIC(void) simcall_comm_wait(smx_action_t comm, double timeout); XBT_PUBLIC(int) simcall_comm_test(smx_action_t comm); XBT_PUBLIC(int) simcall_comm_testany(xbt_dynar_t comms); /* Getters and setters */ XBT_PUBLIC(double) simcall_comm_get_remains(smx_action_t comm); XBT_PUBLIC(e_smx_state_t) simcall_comm_get_state(smx_action_t comm); XBT_PUBLIC(void *) simcall_comm_get_src_data(smx_action_t comm); XBT_PUBLIC(void *) simcall_comm_get_dst_data(smx_action_t comm); XBT_PUBLIC(smx_process_t) simcall_comm_get_src_proc(smx_action_t comm); XBT_PUBLIC(smx_process_t) simcall_comm_get_dst_proc(smx_action_t comm); #ifdef HAVE_LATENCY_BOUND_TRACKING XBT_PUBLIC(int) simcall_comm_is_latency_bounded(smx_action_t comm); #endif #ifdef HAVE_TRACING /************************** Tracing handling **********************************/ XBT_PUBLIC(void) simcall_set_category(smx_action_t action, const char *category); #endif /************************** Synchro simcalls **********************************/ XBT_PUBLIC(smx_mutex_t) simcall_mutex_init(void); XBT_PUBLIC(void) simcall_mutex_destroy(smx_mutex_t mutex); XBT_PUBLIC(void) simcall_mutex_lock(smx_mutex_t mutex); XBT_PUBLIC(int) simcall_mutex_trylock(smx_mutex_t mutex); XBT_PUBLIC(void) simcall_mutex_unlock(smx_mutex_t mutex); XBT_PUBLIC(smx_cond_t) simcall_cond_init(void); XBT_PUBLIC(void) simcall_cond_destroy(smx_cond_t cond); XBT_PUBLIC(void) simcall_cond_signal(smx_cond_t cond); XBT_PUBLIC(void) simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex); XBT_PUBLIC(void) simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double max_duration); XBT_PUBLIC(void) simcall_cond_broadcast(smx_cond_t cond); XBT_PUBLIC(smx_sem_t) simcall_sem_init(int capacity); XBT_PUBLIC(void) simcall_sem_destroy(smx_sem_t sem); XBT_PUBLIC(void) simcall_sem_release(smx_sem_t sem); XBT_PUBLIC(int) simcall_sem_would_block(smx_sem_t sem); XBT_PUBLIC(void) simcall_sem_acquire(smx_sem_t sem); XBT_PUBLIC(void) simcall_sem_acquire_timeout(smx_sem_t sem, double max_duration); XBT_PUBLIC(int) simcall_sem_get_capacity(smx_sem_t sem); /***************************** File **********************************/ XBT_PUBLIC(void *) simcall_file_get_data(smx_file_t fd); XBT_PUBLIC(void) simcall_file_set_data(smx_file_t fd, void *data); XBT_PUBLIC(sg_size_t) simcall_file_read(smx_file_t fd, sg_size_t size, smx_host_t host); XBT_PUBLIC(sg_size_t) simcall_file_write(smx_file_t fd, sg_size_t size, smx_host_t host); XBT_PUBLIC(smx_file_t) simcall_file_open(const char* fullpath, smx_host_t host); XBT_PUBLIC(int) simcall_file_close(smx_file_t fd, smx_host_t host); XBT_PUBLIC(int) simcall_file_unlink(smx_file_t fd, smx_host_t host); XBT_PUBLIC(sg_size_t) simcall_file_get_size(smx_file_t fd); XBT_PUBLIC(xbt_dynar_t) simcall_file_get_info(smx_file_t fd); XBT_PUBLIC(sg_size_t) simcall_file_tell(smx_file_t fd); XBT_PUBLIC(int) simcall_file_seek(smx_file_t fd, sg_offset_t offset, int origin); XBT_PUBLIC(int) simcall_file_move(smx_file_t fd, const char* fullpath); /***************************** Storage **********************************/ XBT_PUBLIC(sg_size_t) simcall_storage_get_free_size (smx_storage_t storage); XBT_PUBLIC(sg_size_t) simcall_storage_get_used_size (smx_storage_t storage); XBT_PUBLIC(xbt_dict_t) simcall_storage_get_properties(smx_storage_t storage); XBT_PUBLIC(void*) SIMIX_storage_get_data(smx_storage_t storage); XBT_PUBLIC(void) SIMIX_storage_set_data(smx_storage_t storage, void *data); XBT_PUBLIC(xbt_dict_t) SIMIX_storage_get_content(smx_storage_t storage); XBT_PUBLIC(xbt_dict_t) simcall_storage_get_content(smx_storage_t storage); XBT_PUBLIC(const char*) SIMIX_storage_get_name(smx_storage_t storage); XBT_PUBLIC(sg_size_t) SIMIX_storage_get_size(smx_storage_t storage); XBT_PUBLIC(const char*) SIMIX_storage_get_host(smx_storage_t storage); /************************** AS router **********************************/ XBT_PUBLIC(xbt_dict_t) SIMIX_asr_get_properties(const char *name); /************************** AS router simcalls ***************************/ XBT_PUBLIC(xbt_dict_t) simcall_asr_get_properties(const char *name); /************************** MC simcalls **********************************/ XBT_PUBLIC(void *) simcall_mc_snapshot(void); XBT_PUBLIC(int) simcall_mc_compare_snapshots(void *s1, void *s2); XBT_PUBLIC(int) simcall_mc_random(int min, int max); /************************** New API simcalls **********************************/ /* TUTORIAL: New API */ /******************************************************************************/ XBT_PUBLIC(int) simcall_new_api_fct(const char* param1, double param2); SG_END_DECL() #endif /* _SIMIX_SIMIX_H */ SimGrid-3.11/include/simgrid/platf.h000644 001750 001750 00000033422 12342443646 016400 0ustar00cici000000 000000 /* platf.h - Public interface to the SimGrid platforms */ /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef SG_PLATF_H #define SG_PLATF_H #include SG_BEGIN_DECL() typedef void *sg_routing_link_t; /* FIXME:The actual type is model-dependent so use void* instead*/ typedef struct RoutingEdge *sg_routing_edge_t; XBT_PUBLIC(sg_routing_edge_t) sg_routing_edge_by_name_or_null(const char *name); /** @ingroup SURF_interface * @brief Defines whether a given resource is working or not */ typedef enum { SURF_RESOURCE_ON = 1, /**< Up & ready */ SURF_RESOURCE_OFF = 0 /**< Down & broken */ } e_surf_resource_state_t; typedef enum { SURF_LINK_FULLDUPLEX = 2, SURF_LINK_SHARED = 1, SURF_LINK_FATPIPE = 0 } e_surf_link_sharing_policy_t; typedef enum { SURF_TRACE_CONNECT_KIND_HOST_AVAIL = 4, SURF_TRACE_CONNECT_KIND_POWER = 3, SURF_TRACE_CONNECT_KIND_LINK_AVAIL = 2, SURF_TRACE_CONNECT_KIND_BANDWIDTH = 1, SURF_TRACE_CONNECT_KIND_LATENCY = 0 } e_surf_trace_connect_kind_t; typedef enum { SURF_PROCESS_ON_FAILURE_DIE = 1, SURF_PROCESS_ON_FAILURE_RESTART = 0 } e_surf_process_on_failure_t; typedef enum { SURF_CLUSTER_FAT_TREE=2, SURF_CLUSTER_FLAT = 1, SURF_CLUSTER_TORUS = 0 } e_surf_cluster_topology_t; typedef struct tmgr_trace *tmgr_trace_t; /**< Opaque structure defining an availability trace */ /** opaque structure defining a event generator for availability based on a probability distribution */ typedef struct probabilist_event_generator *probabilist_event_generator_t; XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_file(const char *filename); XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_string(const char *id, const char *input, double periodicity); XBT_PUBLIC(tmgr_trace_t) tmgr_trace_generator_value(const char *id, probabilist_event_generator_t date_generator, probabilist_event_generator_t value_generator); XBT_PUBLIC(tmgr_trace_t) tmgr_trace_generator_state(const char *id, probabilist_event_generator_t date_generator, e_surf_resource_state_t first_event_value); XBT_PUBLIC(tmgr_trace_t) tmgr_trace_generator_avail_unavail(const char *id, probabilist_event_generator_t avail_duration_generator, probabilist_event_generator_t unavail_duration_generator, e_surf_resource_state_t first_event_value); XBT_PUBLIC(probabilist_event_generator_t) tmgr_event_generator_new_uniform(const char* id, double min, double max); XBT_PUBLIC(probabilist_event_generator_t) tmgr_event_generator_new_exponential(const char* id, double rate); XBT_PUBLIC(probabilist_event_generator_t) tmgr_event_generator_new_weibull(const char* id, double scale, double shape); typedef xbt_dictelm_t sg_host_t; static inline char* sg_host_name(sg_host_t host) { return host->key; } typedef xbt_dictelm_t sg_storage_t; static inline char* sg_storage_name(sg_storage_t storage) { return storage->key; } /** @ingroup m_datatypes_management_details * @brief Type for any simgrid size */ typedef unsigned long long sg_size_t; /** @ingroup m_datatypes_management_details * @brief Type for any simgrid offset */ typedef long long sg_offset_t; /* * Platform creation functions. Instead of passing 123 arguments to the creation functions * (one for each possible XML attribute), we pass structures containing them all. It removes the * chances of switching arguments by error, and reduce the burden when we add a new attribute: * old models can just continue to ignore it without having to update their headers. * * It shouldn't be too costly at runtime, provided that structures living on the stack are * used, instead of malloced structures. */ typedef struct { const char* id; xbt_dynar_t power_peak; int pstate; int core_amount; double power_scale; tmgr_trace_t power_trace; e_surf_resource_state_t initial_state; tmgr_trace_t state_trace; const char* coord; xbt_dict_t properties; } s_sg_platf_host_cbarg_t, *sg_platf_host_cbarg_t; #define SG_PLATF_HOST_INITIALIZER { \ .id = NULL,\ .power_peak = 0,\ .core_amount = 1.,\ .power_scale = 1,\ .initial_state = SURF_RESOURCE_ON,\ .power_trace = NULL,\ .state_trace = NULL,\ .coord = NULL,\ .properties = NULL\ } typedef struct { const char* id; const char* link_up; const char* link_down; } s_sg_platf_host_link_cbarg_t, *sg_platf_host_link_cbarg_t; #define SG_PLATF_HOST_LINK_INITIALIZER {NULL,NULL,NULL} typedef struct { const char* id; const char* coord; } s_sg_platf_router_cbarg_t, *sg_platf_router_cbarg_t; #define SG_PLATF_ROUTER_INITIALIZER {NULL,NULL} typedef struct { const char* id; double bandwidth; tmgr_trace_t bandwidth_trace; double latency; tmgr_trace_t latency_trace; e_surf_resource_state_t state; tmgr_trace_t state_trace; e_surf_link_sharing_policy_t policy; xbt_dict_t properties; } s_sg_platf_link_cbarg_t, *sg_platf_link_cbarg_t; #define SG_PLATF_LINK_INITIALIZER {\ .id = NULL,\ .bandwidth = 0.,\ .bandwidth_trace = NULL,\ .latency = 0.,\ .latency_trace = NULL,\ .state = SURF_RESOURCE_ON,\ .state_trace = NULL,\ .policy = SURF_LINK_SHARED,\ .properties = NULL\ } typedef struct s_sg_platf_peer_cbarg *sg_platf_peer_cbarg_t; typedef struct s_sg_platf_peer_cbarg { const char* id; double power; double bw_in; double bw_out; double lat; const char* coord; tmgr_trace_t availability_trace; tmgr_trace_t state_trace; } s_sg_platf_peer_cbarg_t; #define SG_PLATF_PEER_INITIALIZER {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL} typedef struct s_sg_platf_route_cbarg *sg_platf_route_cbarg_t; typedef struct s_sg_platf_route_cbarg { int symmetrical; const char *src; const char *dst; sg_routing_edge_t gw_src; sg_routing_edge_t gw_dst; xbt_dynar_t link_list; } s_sg_platf_route_cbarg_t; #define SG_PLATF_ROUTE_INITIALIZER {TRUE,NULL,NULL,NULL,NULL,NULL} typedef struct s_sg_platf_cluster_cbarg *sg_platf_cluster_cbarg_t; typedef struct s_sg_platf_cluster_cbarg { const char* id; const char* prefix; const char* suffix; const char* radical; double power; int core_amount; double bw; double lat; double bb_bw; double bb_lat; double loopback_bw; double loopback_lat; double limiter_link; e_surf_cluster_topology_t topology; const char* topo_parameters; xbt_dict_t properties; const char* router_id; e_surf_link_sharing_policy_t sharing_policy; e_surf_link_sharing_policy_t bb_sharing_policy; const char* availability_trace; //don't convert to tmgr_trace_t since there is a trace per host and some rewriting is needed const char* state_trace; } s_sg_platf_cluster_cbarg_t; #define SG_PLATF_CLUSTER_INITIALIZER {NULL,NULL,NULL,NULL,NULL,NULL \ ,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL} typedef struct s_sg_platf_cabinet_cbarg *sg_platf_cabinet_cbarg_t; typedef struct s_sg_platf_cabinet_cbarg { const char* id; const char* prefix; const char* suffix; const char* radical; double power; double bw; double lat; } s_sg_platf_cabinet_cbarg_t; #define SG_PLATF_CABINET_INITIALIZER {NULL,NULL,NULL,NULL,NULL,NULL,NULL} typedef struct { const char* id; const char* type_id; const char* content; const char* content_type; xbt_dict_t properties; const char* attach; } s_sg_platf_storage_cbarg_t, *sg_platf_storage_cbarg_t; #define SG_PLATF_STORAGE_INITIALIZER {NULL,NULL,NULL,NULL} typedef struct { const char* id; const char* model; const char* content; const char* content_type; xbt_dict_t properties; xbt_dict_t model_properties; sg_size_t size; } s_sg_platf_storage_type_cbarg_t, *sg_platf_storage_type_cbarg_t; #define SG_PLATF_STORAGE_TYPE_INITIALIZER {NULL,NULL,NULL,NULL,NULL} typedef struct { const char* type_id; const char* name; } s_sg_platf_mstorage_cbarg_t, *sg_platf_mstorage_cbarg_t; #define SG_PLATF_MSTORAGE_INITIALIZER {NULL,NULL} typedef struct { const char* storageId; const char* name; } s_sg_platf_mount_cbarg_t, *sg_platf_mount_cbarg_t; #define SG_PLATF_MOUNT_INITIALIZER {NULL,NULL} typedef struct s_sg_platf_prop_cbarg *sg_platf_prop_cbarg_t; typedef struct s_sg_platf_prop_cbarg { const char *id; const char *value; } s_sg_platf_prop_cbarg_t; #define SG_PLATF_PROP_INITIALIZER {NULL,NULL} typedef struct s_sg_platf_trace_cbarg *sg_platf_trace_cbarg_t; typedef struct s_sg_platf_trace_cbarg { const char *id; const char *file; double periodicity; const char *pc_data; } s_sg_platf_trace_cbarg_t; #define SG_PLATF_TRACE_INITIALIZER {NULL,NULL,NULL,NULL} typedef struct s_sg_platf_trace_connect_cbarg *sg_platf_trace_connect_cbarg_t; typedef struct s_sg_platf_trace_connect_cbarg { e_surf_trace_connect_kind_t kind; const char *trace; const char *element; } s_sg_platf_trace_connect_cbarg_t; #define SG_PLATF_TRACE_CONNECT_INITIALIZER {NULL,NULL,NULL} typedef struct s_sg_platf_process_cbarg *sg_platf_process_cbarg_t; typedef struct s_sg_platf_process_cbarg { const char **argv; int argc; xbt_dict_t properties; const char *host; const char *function; double start_time; double kill_time; e_surf_process_on_failure_t on_failure; } s_sg_platf_process_cbarg_t; #define SG_PLATF_PROCESS_INITIALIZER {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL} typedef struct s_sg_platf_AS_cbarg *sg_platf_AS_cbarg_t; typedef struct s_sg_platf_AS_cbarg { const char *id; int routing; } s_sg_platf_AS_cbarg_t; #define SG_PLATF_AS_INITIALIZER {NULL,0} /* ***************************************** */ /* TUTORIAL: New TAG */ typedef struct s_sg_platf_gpu_cbarg *sg_platf_gpu_cbarg_t; typedef struct s_sg_platf_gpu_cbarg { const char *name; } s_sg_platf_gpu_cbarg_t; #define SG_PLATF_GPU_INITIALIZER {NULL} /* ***************************************** */ XBT_PUBLIC(void) sg_platf_begin(void); // Start a new platform XBT_PUBLIC(void) sg_platf_end(void); // Finish the creation of the platform XBT_PUBLIC(void) sg_platf_new_AS_begin(sg_platf_AS_cbarg_t AS); // Begin description of new AS XBT_PUBLIC(void) sg_platf_new_AS_end(void); // That AS is fully described XBT_PUBLIC(void) sg_platf_new_host (sg_platf_host_cbarg_t host); // Add an host to the currently described AS XBT_PUBLIC(void) sg_platf_new_host_link(sg_platf_host_link_cbarg_t h); // Add an host_link to the currently described AS XBT_PUBLIC(void) sg_platf_new_router (sg_platf_router_cbarg_t router); // Add a router to the currently described AS XBT_PUBLIC(void) sg_platf_new_link (sg_platf_link_cbarg_t link); // Add a link to the currently described AS XBT_PUBLIC(void) sg_platf_new_peer (sg_platf_peer_cbarg_t peer); // Add a peer to the currently described AS XBT_PUBLIC(void) sg_platf_new_cluster(sg_platf_cluster_cbarg_t clust); // Add a cluster to the currently described AS XBT_PUBLIC(void) sg_platf_new_cabinet(sg_platf_cabinet_cbarg_t cabinet); // Add a cabinet to the currently described AS XBT_PUBLIC(void) sg_platf_new_route (sg_platf_route_cbarg_t route); // Add a route XBT_PUBLIC(void) sg_platf_new_ASroute (sg_platf_route_cbarg_t ASroute); // Add an ASroute XBT_PUBLIC(void) sg_platf_new_bypassRoute (sg_platf_route_cbarg_t bypassroute); // Add a bypassRoute XBT_PUBLIC(void) sg_platf_new_bypassASroute (sg_platf_route_cbarg_t bypassASroute); // Add an bypassASroute XBT_PUBLIC(void) sg_platf_new_prop (sg_platf_prop_cbarg_t prop); // Add a prop XBT_PUBLIC(void) sg_platf_new_trace(sg_platf_trace_cbarg_t trace); XBT_PUBLIC(void) sg_platf_trace_connect(sg_platf_trace_connect_cbarg_t trace_connect); XBT_PUBLIC(void) sg_platf_new_storage(sg_platf_storage_cbarg_t storage); // Add a storage to the currently described AS XBT_PUBLIC(void) sg_platf_new_mstorage(sg_platf_mstorage_cbarg_t mstorage); XBT_PUBLIC(void) sg_platf_new_storage_type(sg_platf_storage_type_cbarg_t storage_type); XBT_PUBLIC(void) sg_platf_new_mount(sg_platf_mount_cbarg_t mount); XBT_PUBLIC(void) sg_platf_new_process(sg_platf_process_cbarg_t process); /* ***************************************** */ /* TUTORIAL: New TAG */ XBT_PUBLIC(void) sg_platf_new_gpu(sg_platf_gpu_cbarg_t gpu); /* ***************************************** */ // Add route and Asroute without xml file with those functions XBT_PUBLIC(void) sg_platf_route_begin (sg_platf_route_cbarg_t route); // Initialize route XBT_PUBLIC(void) sg_platf_route_end (sg_platf_route_cbarg_t route); // Finalize and add a route XBT_PUBLIC(void) sg_platf_ASroute_begin (sg_platf_route_cbarg_t ASroute); // Initialize ASroute XBT_PUBLIC(void) sg_platf_ASroute_end (sg_platf_route_cbarg_t ASroute); // Finalize and add a ASroute XBT_PUBLIC(void) sg_platf_route_add_link (const char* link_id, sg_platf_route_cbarg_t route); // Add a link to link list XBT_PUBLIC(void) sg_platf_ASroute_add_link (const char* link_id, sg_platf_route_cbarg_t ASroute); // Add a link to link list typedef void (*sg_platf_process_cb_t)(sg_platf_process_cbarg_t); XBT_PUBLIC(void) sg_platf_process_add_cb(sg_platf_process_cb_t fct); SG_END_DECL() #endif /* SG_PLATF_H */ SimGrid-3.11/include/simgrid/modelchecker.h000644 001750 001750 00000003165 12342443646 017720 0ustar00cici000000 000000 /* simgrid/modelchecker.h - Formal Verification made possible in SimGrid */ /* Copyright (c) 2008-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include /* HAVE_MC ? */ #include #include "xbt/automaton.h" #ifndef SIMGRID_MODELCHECKER_H #define SIMGRID_MODELCHECKER_H SG_BEGIN_DECL() #ifdef HAVE_MC extern int _sg_do_model_check; /* please don't use directly: we inline MC_is_active, but that's what you should use */ extern int _sg_mc_visited; #define MC_is_active() _sg_do_model_check #define MC_visited_reduction() _sg_mc_visited XBT_PUBLIC(void) MC_assert(int); XBT_PUBLIC(int) MC_random(int min, int max); XBT_PUBLIC(void) MC_automaton_new_propositional_symbol(const char* id, void* fct); XBT_PUBLIC(void *) MC_snapshot(void); XBT_PUBLIC(int) MC_compare_snapshots(void *s1, void *s2); XBT_PUBLIC(void) MC_cut(void); XBT_PUBLIC(void) MC_ignore(void *addr, size_t size); #else #define MC_is_active() 0 #define MC_visited_reduction() 0 #define MC_assert(a) xbt_assert(a) #define MC_random(a, b) 0 #define MC_automaton_new_propositional_symbol(a, b) ((void)0) #define MC_snapshot() ((void*)0) #define MC_compare_snapshots(a, b) 0 #define MC_cut() ((void)0) #define MC_ignore(a, b) ((void)0) #endif SG_END_DECL() #endif /* SIMGRID_MODELCHECKER_H */ SimGrid-3.11/include/simgrid/plugins.h000644 001750 001750 00000000755 12342443646 016756 0ustar00cici000000 000000 /* Copyright (c) 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef PLUGINS_H_ #define PLUGINS_H_ SG_BEGIN_DECL() /** \ingroup SURF_plugins * \brief The cpu energy consumption plugin */ XBT_PUBLIC(void) sg_energy_plugin_init(void); SG_END_DECL() #endif /* PLUGINS_H_ */ SimGrid-3.11/include/simgrid/platf_generator.h000644 001750 001750 00000005326 12342443646 020450 0ustar00cici000000 000000 /* platf_generator.h - Public interface to the SimGrid platforms generator */ /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef SG_PLATF_GEN_H #define SG_PLATF_GEN_H #include "xbt.h" #include "xbt/graph.h" //Only for platf_graph_get() #include "platf.h" typedef enum { ROUTER, HOST, CLUSTER } e_platf_node_kind; typedef struct s_context_node_t { unsigned long id; double x, y; int degree; e_platf_node_kind kind; int connect_checked; union { s_sg_platf_host_cbarg_t host_parameters; s_sg_platf_cluster_cbarg_t cluster_parameters; char* router_id; }; } s_context_node_t, *context_node_t; typedef struct s_context_edge_t { unsigned long id; double length; int labeled; s_sg_platf_link_cbarg_t link_parameters; } s_context_edge_t, *context_edge_t; typedef void (*platf_promoter_cb_t) (context_node_t); typedef void (*platf_labeler_cb_t) (context_edge_t); XBT_PUBLIC(void) platf_random_seed(unsigned long seed[6]); XBT_PUBLIC(void) platf_graph_uniform(unsigned long node_count); XBT_PUBLIC(void) platf_graph_heavytailed(unsigned long node_count); XBT_PUBLIC(void) platf_graph_interconnect_star(void); XBT_PUBLIC(void) platf_graph_interconnect_line(void); XBT_PUBLIC(void) platf_graph_interconnect_ring(void); XBT_PUBLIC(void) platf_graph_interconnect_clique(void); XBT_PUBLIC(void) platf_graph_interconnect_uniform(double alpha); XBT_PUBLIC(void) platf_graph_interconnect_exponential(double alpha); XBT_PUBLIC(void) platf_graph_interconnect_zegura(double alpha, double beta, double r); XBT_PUBLIC(void) platf_graph_interconnect_waxman(double alpha, double beta); XBT_PUBLIC(void) platf_graph_interconnect_barabasi(void); XBT_PUBLIC(int) platf_graph_is_connected(void); XBT_PUBLIC(void) platf_graph_clear_links(void); XBT_PUBLIC(void) platf_graph_promote_to_host(context_node_t node, sg_platf_host_cbarg_t parameters); XBT_PUBLIC(void) platf_graph_promote_to_cluster(context_node_t node, sg_platf_cluster_cbarg_t parameters); XBT_PUBLIC(void) platf_graph_link_label(context_edge_t edge, sg_platf_link_cbarg_t parameters); XBT_PUBLIC(void) platf_graph_promoter(platf_promoter_cb_t promoter_callback); XBT_PUBLIC(void) platf_graph_labeler(platf_labeler_cb_t labeler_callback); XBT_PUBLIC(void) platf_do_promote(void); XBT_PUBLIC(void) platf_do_label(void); XBT_PUBLIC(void) platf_generate(void); // WARNING : Only for debbugging ; should be removed when platform // generation works correctly XBT_PUBLIC(xbt_graph_t) platf_graph_get(void); #endif /* SG_PLATF_GEN_H */ SimGrid-3.11/include/simgrid/datatypes.h000644 001750 001750 00000001515 12342443646 017266 0ustar00cici000000 000000 /* Copyright (c) 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef SIMGRID_DATATYPES_H_ #define SIMGRID_DATATYPES_H_ typedef struct ws_params { int ncpus; sg_size_t ramsize; int overcommit; /* The size of other states than memory pages, which is out-of-scope of dirty * page tracking. */ sg_size_t devsize; int skip_stage1; int skip_stage2; double max_downtime; double dp_rate; double dp_cap; /* bytes per 1 flop execution */ double xfer_cpu_overhead; double dpt_cpu_overhead; /* set migration speed */ double mig_speed; } s_ws_params_t, *ws_params_t; #endif /* SIMGRID_DATATYPES_H_ */ SimGrid-3.11/include/xbt.h000644 001750 001750 00000001630 12342443646 014425 0ustar00cici000000 000000 /* xbt.h - Public interface to the xbt (SimGrid's toolbox) */ /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef xbt_H #define xbt_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #endif /* xbt_H */ SimGrid-3.11/include/smpi/000755 001750 001750 00000000000 12342443646 014427 5ustar00cici000000 000000 SimGrid-3.11/include/smpi/mpi.h000644 001750 001750 00000001155 12342443646 015367 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef MPI_H #define MPI_H #define SEED 221238 #define sleep(x) smpi_sleep(x) #include #include #include #include #include #define gettimeofday(x, y) smpi_gettimeofday(x, NULL) #ifdef HAVE_MC #undef assert #define assert(x) MC_assert(x) #endif #endif SimGrid-3.11/include/smpi/mpif.h.in000644 001750 001750 00000022250 12342443646 016141 0ustar00cici000000 000000 ! -*- fortran -*- ! Copyright (c) 2010, 2012-2014. The SimGrid Team. ! All rights reserved. ! This program is free software; you can redistribute it and/or modify it ! under the terms of the license (GNU LGPL) which comes with this package. ! SMPI's Fortran 77 include file integer MPI_THREAD_SINGLE, MPI_THREAD_FUNNELED integer MPI_THREAD_SERIALIZED, MPI_THREAD_MULTIPLE parameter(MPI_THREAD_SINGLE=0) parameter(MPI_THREAD_FUNNELED=1) parameter(MPI_THREAD_SERIALIZED=2) parameter(MPI_THREAD_MULTIPLE=3) integer MPI_MAX_PROCESSOR_NAME, MPI_MAX_ERROR_STRING integer MPI_MAX_DATAREP_STRIN, MPI_MAX_INFO_KEY integer MPI_MAX_INFO_VAL, MPI_MAX_OBJECT_NAME, MPI_MAX_PORT_NAME integer MPI_ANY_SOURCE, MPI_PROC_NULL, MPI_ANY_TAG, MPI_UNDEFINED integer MPI_TAG_UB, MPI_TAG_LB integer MPI_SOURCE, MPI_TAG, MPI_ERROR integer MPI_VERSION, MPI_SUBVERSION parameter(MPI_MAX_PROCESSOR_NAME=100) parameter(MPI_MAX_ERROR_STRING=100) parameter(MPI_MAX_DATAREP_STRIN =100) parameter(MPI_MAX_INFO_KEY=100) parameter(MPI_MAX_INFO_VAL=100) parameter(MPI_MAX_OBJECT_NAME=100) parameter(MPI_MAX_PORT_NAME=100) parameter(MPI_ANY_SOURCE=-555) parameter(MPI_PROC_NULL=-666) parameter(MPI_ANY_TAG=-444) parameter(MPI_UNDEFINED=-333) parameter(MPI_SOURCE=1) parameter(MPI_TAG=2) parameter(MPI_ERROR=3) parameter(MPI_TAG_UB=0) parameter(MPI_TAG_LB=0) parameter(MPI_VERSION=1) parameter(MPI_SUBVERSION=1) integer MPI_SUCCESS, MPI_ERR_COMM, MPI_ERR_ARG, MPI_ERR_TYPE integer MPI_ERR_REQUEST, MPI_ERR_INTERN, MPI_ERR_COUNT integer MPI_ERR_RANK, MPI_ERR_OTHER, MPI_ERR_UNKNOWN integer MPI_ERR_TAG, MPI_ERR_TRUNCATE, MPI_ERR_GROUP, MPI_ERR_OP integer MPI_LASTUSEDCODE, MPI_ERR_LASTCODE integer MPI_IDENT, MPI_SIMILAR, MPI_UNEQUAL, MPI_CONGRUENT integer MPI_WTIME_IS_GLOBAL parameter(MPI_SUCCESS=0) parameter(MPI_ERR_COMM=1) parameter(MPI_ERR_ARG=2) parameter(MPI_ERR_TYPE=3) parameter(MPI_ERR_REQUEST=4) parameter(MPI_ERR_INTERN=5) parameter(MPI_ERR_COUNT=6) parameter(MPI_ERR_RANK=7) parameter(MPI_ERR_TAG=8) parameter(MPI_ERR_TRUNCATE=9) parameter(MPI_ERR_GROUP=10) parameter(MPI_ERR_OP=11) parameter(MPI_ERR_OTHER=12) parameter(MPI_ERR_UNKNOWN=13) parameter(MPI_LASTUSEDCODE=0) parameter(MPI_ERR_LASTCODE=0) parameter(MPI_IDENT=0) parameter(MPI_SIMILAR=1) parameter(MPI_UNEQUAL=2) parameter(MPI_CONGRUENT=3) parameter(MPI_WTIME_IS_GLOBAL=1) integer MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN parameter(MPI_NULL_COPY_FN =0) parameter(MPI_NULL_DELETE_FN =0) integer MPI_COMM_NULL_COPY_FN, MPI_COMM_NULL_DELETE_FN parameter(MPI_COMM_NULL_COPY_FN =0) parameter(MPI_COMM_NULL_DELETE_FN =0) integer MPI_COMM_NULL_DUP_FN, MPI_COMM_DUP_FN parameter(MPI_COMM_NULL_DUP_FN =0) parameter(MPI_COMM_DUP_FN =0) integer MPI_APPNUM, MPI_HOST, MPI_IO parameter(MPI_APPNUM=0) parameter(MPI_HOST=0) parameter(MPI_IO=0) integer MPI_ROOT, MPI_INFO_NULL,MPI_COMM_TYPE_SHARED parameter(MPI_ROOT=0) parameter(MPI_INFO_NULL=-1) parameter(MPI_COMM_TYPE_SHARED=1) ! These should be ordered as in smpi_f77.c integer MPI_COMM_NULL, MPI_COMM_WORLD, MPI_COMM_SELF integer MPI_UNIVERSE_SIZE parameter(MPI_COMM_NULL=-1) parameter(MPI_COMM_SELF=-2) parameter(MPI_COMM_WORLD=0) parameter(MPI_UNIVERSE_SIZE=0) integer MPI_GROUP_NULL, MPI_GROUP_EMPTY parameter(MPI_GROUP_NULL=-1) parameter(MPI_GROUP_EMPTY=-2) integer MPI_ERRORS_RETURN, MPI_ERRORS_ARE_FATAL integer MPI_ERRHANDLER_NULL parameter(MPI_ERRORS_RETURN=0) parameter(MPI_ERRORS_ARE_FATAL=1) parameter(MPI_ERRHANDLER_NULL=2) ! This should be equal to the number of int fields in MPI_Status integer MPI_STATUS_SIZE parameter(MPI_STATUS_SIZE=4) ! These should be ordered as in smpi_f77.c integer MPI_IN_PLACE, MPI_BOTTOM integer MPI_STATUS_IGNORE, MPI_STATUSES_IGNORE common /smpi/ MPI_IN_PLACE, MPI_BOTTOM common /smpi/ MPI_STATUS_IGNORE, MPI_STATUSES_IGNORE integer MPI_REQUEST_NULL parameter(MPI_REQUEST_NULL=-1) integer MPI_INTEGER_KIND parameter(MPI_INTEGER_KIND=4) integer MPI_DATATYPE_NULL, MPI_BYTE, MPI_CHARACTER, MPI_LOGICAL integer MPI_INTEGER, MPI_INTEGER1, MPI_INTEGER2, MPI_INTEGER4 integer MPI_INTEGER8, MPI_REAL, MPI_REAL4, MPI_REAL8 integer MPI_DOUBLE_PRECISION, MPI_COMPLEX, MPI_DOUBLE_COMPLEX integer MPI_2INTEGER, MPI_LOGICAL1, MPI_LOGICAL2, MPI_LOGICAL4 integer MPI_LOGICAL8, MPI_2REAL, MPI_2DOUBLE_PRECISION integer MPI_AINT, MPI_OFFSET, MPI_COUNT integer MPI_REAL16, MPI_COMPLEX8,MPI_COMPLEX16,MPI_COMPLEX32 parameter(MPI_DATATYPE_NULL=-1) parameter(MPI_BYTE=0) parameter(MPI_CHARACTER=1) parameter(MPI_LOGICAL=2) parameter(MPI_INTEGER=3) parameter(MPI_INTEGER1=4) parameter(MPI_INTEGER2=5) parameter(MPI_INTEGER4=6) parameter(MPI_INTEGER8=7) parameter(MPI_REAL=8) parameter(MPI_REAL4=9) parameter(MPI_REAL8=10) parameter(MPI_DOUBLE_PRECISION=11) parameter(MPI_COMPLEX=12) parameter(MPI_DOUBLE_COMPLEX=13) parameter(MPI_2INTEGER=14) parameter(MPI_LOGICAL1=15) parameter(MPI_LOGICAL2=16) parameter(MPI_LOGICAL4=17) parameter(MPI_LOGICAL8=18) parameter(MPI_2REAL=19) parameter(MPI_2DOUBLE_PRECISION=19) parameter(MPI_AINT=20) parameter(MPI_OFFSET=21) parameter(MPI_COUNT=22) parameter(MPI_REAL16=23) parameter(MPI_COMPLEX8=24) parameter(MPI_COMPLEX16=25) parameter(MPI_COMPLEX32=26) ! These should be ordered as in smpi_f77.c integer MPI_OP_NULL,MPI_MAX, MPI_MIN, MPI_MAXLOC, MPI_MINLOC integer MPI_SUM, MPI_PROD, MPI_LAND, MPI_LOR, MPI_LXOR, MPI_BAND integer MPI_BOR, MPI_BXOR parameter(MPI_OP_NULL=-1) parameter(MPI_MAX=0) parameter(MPI_MIN=1) parameter(MPI_MAXLOC=2) parameter(MPI_MINLOC=3) parameter(MPI_SUM=4) parameter(MPI_PROD=5) parameter(MPI_LAND=6) parameter(MPI_LOR=7) parameter(MPI_LXOR=8) parameter(MPI_BAND=9) parameter(MPI_BOR=10) parameter(MPI_BXOR=11) INTEGER MPI_ADDRESS_KIND, MPI_OFFSET_KIND PARAMETER (MPI_ADDRESS_KIND=@MPI_ADDRESS_SIZE@) PARAMETER (MPI_OFFSET_KIND=@MPI_ADDRESS_SIZE@) INTEGER MPI_MODE_NOPRECEDE PARAMETER (MPI_MODE_NOPRECEDE=8192) integer MPI_COMBINER_NAMED, MPI_COMBINER_DUP integer MPI_COMBINER_CONTIGUOUS, MPI_COMBINER_VECTOR integer MPI_COMBINER_HVECTOR_INTEGER, MPI_COMBINER_HVECTOR integer MPI_COMBINER_INDEXED, MPI_COMBINER_HINDEXED_INTEGER integer MPI_COMBINER_HINDEXED, MPI_COMBINER_INDEXED_BLOCK integer MPI_COMBINER_STRUCT_INTEGER, MPI_COMBINER_STRUCT integer MPI_COMBINER_SUBARRAY, MPI_COMBINER_DARRAY integer MPI_COMBINER_F90_REAL, MPI_COMBINER_F90_COMPLEX integer MPI_COMBINER_F90_INTEGER, MPI_COMBINER_RESIZED integer MPI_COMBINER_HINDEXED_BLOCK parameter( MPI_COMBINER_NAMED=0) parameter( MPI_COMBINER_DUP=1) parameter( MPI_COMBINER_CONTIGUOUS=2) parameter( MPI_COMBINER_VECTOR=3) parameter( MPI_COMBINER_HVECTOR_INTEGER=4) parameter( MPI_COMBINER_HVECTOR=5) parameter( MPI_COMBINER_INDEXED=6) parameter( MPI_COMBINER_HINDEXED_INTEGER=7) parameter( MPI_COMBINER_HINDEXED=8) parameter( MPI_COMBINER_INDEXED_BLOCK=9) parameter( MPI_COMBINER_STRUCT_INTEGER=10) parameter( MPI_COMBINER_STRUCT=11) parameter( MPI_COMBINER_SUBARRAY=12) parameter( MPI_COMBINER_DARRAY=13) parameter( MPI_COMBINER_F90_REAL=14) parameter( MPI_COMBINER_F90_COMPLEX=15) parameter( MPI_COMBINER_F90_INTEGER=16) parameter( MPI_COMBINER_RESIZED=17) parameter( MPI_COMBINER_HINDEXED_BLOCK=18) integer MPI_ORDER_C, MPI_ORDER_FORTRAN parameter(MPI_ORDER_C=1) parameter(MPI_ORDER_FORTRAN=0) external MPI_INIT, MPI_FINALIZE, MPI_ABORT external MPI_COMM_RANK, MPI_COMM_SIZE, MPI_COMM_DUP, MPI_COMM_SPLIT external MPI_SEND_INIT, MPI_ISEND, MPI_SEND external MPI_RECV_INIT, MPI_IRECV, MPI_RECV external MPI_START, MPI_STARTALL external MPI_WAIT, MPI_WAITANY, MPI_WAITALL external MPI_BCAST, MPI_BARRIER, MPI_REDUCE, MPI_ALLREDUCE external MPI_SCATTER, MPI_GATHER, MPI_ALLGATHER, MPI_SCAN external MPI_ALLTOALL, MPI_GATHERV, MPI_SENDRECV external MPI_WTIME external MPI_WTICK double precision MPI_WTIME double precision MPI_WTICK external smpi_execute_flops external smpi_execute external smpi_get_host_power_peak_at external smpi_get_host_current_power_peak external smpi_get_host_nb_pstates external smpi_set_host_power_peak_at external smpi_get_host_consumed_energy double precision smpi_get_host_power_peak_at double precision smpi_get_host_current_power_peak integer smpi_get_host_nb_pstates double precision smpi_get_host_consumed_energy SimGrid-3.11/include/smpi/smpif.h.in000644 001750 001750 00000002242 12342443646 016323 0ustar00cici000000 000000 /* Copyright (c) 2007-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef SMPIF_H #define SMPIF_H #cmakedefine SMPI_F2C @SMPI_F2C@ #ifdef SMPI_F2C #include #include /* those are defined in f2c.h */ #undef min #undef max #include XBT_PUBLIC_DATA(__thread int) smpi_current_rank; XBT_PUBLIC(int) smpi_process_argc(void); XBT_PUBLIC(int) smpi_process_getarg(integer* index, char* dst, ftnlen len); #define smpi_sample_local__(pi,pt) \ { \ if(smpi_sample_1(0, __FILE__, __LINE__, *pi, *pt)) { \ smpi_sample_3(0, __FILE__, __LINE__); \ } \ if(!smpi_sample_2(0, __FILE__, __LINE__)) { \ continue; \ } \ } #define smpi_sample_global__(pi,pt) \ { \ if(smpi_sample_1(1, __FILE__, __LINE__, *pi, *pt)) { \ smpi_sample_3(1, __FILE__, __LINE__); \ } \ if(!smpi_sample_2(1, __FILE__, __LINE__)) { \ continue; \ } \ } #endif #endif // SMPI_F2C SimGrid-3.11/include/smpi/smpi_cocci.h000644 001750 001750 00000006601 12342443646 016713 0ustar00cici000000 000000 /* Copyright (c) 2011-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef SMPI_COCCI_H #define SMPI_COCCI_H #include /* Macros used by coccinelle-generated code */ #define SMPI_VARINIT_GLOBAL(name,type) \ type *name = NULL; \ static void __attribute__((constructor)) __preinit_##name(void) { \ if(!name) \ name = (type*)calloc(smpi_global_size(), sizeof(type)); \ } \ static void __attribute__((destructor)) __postfini_##name(void) { \ free(name); \ name = NULL; \ } #define SMPI_VARINIT_GLOBAL_AND_SET(name,type,expr) \ type *name = NULL; \ static void __attribute__((constructor)) __preinit_##name(void) { \ size_t size = smpi_global_size(); \ size_t i; \ type value = expr; \ if(!name) { \ name = (type*)malloc(size * sizeof(type)); \ for(i = 0; i < size; i++) { \ name[i] = value; \ } \ } \ } \ static void __attribute__((destructor)) __postfini_##name(void) { \ free(name); \ name = NULL; \ } #define SMPI_VARGET_GLOBAL(name) name[smpi_process_index()] /* The following handle local static variables */ /** @brief Make sure that the passed pointer is freed on process exit. * * This function is rather internal, mainly used for the * privatization of global variables through coccinelle. */ XBT_PUBLIC(void) smpi_register_static(void* arg, void_f_pvoid_t free_fn); XBT_PUBLIC(void) smpi_free_static(void); #define SMPI_VARINIT_STATIC(name,type) \ static type *name = NULL; \ if(!name) { \ name = (type*)calloc(smpi_global_size(), sizeof(type)); \ smpi_register_static(name, xbt_free); \ } #define SMPI_VARINIT_STATIC_AND_SET(name,type,expr) \ static type *name = NULL; \ if(!name) { \ size_t size = smpi_global_size(); \ size_t i; \ type value = expr; \ name = (type*)malloc(size * sizeof(type)); \ for(i = 0; i < size; i++) { \ name[i] = value; \ } \ smpi_register_static(name, xbt_free); \ } #define SMPI_VARGET_STATIC(name) name[smpi_process_index()] #endif SimGrid-3.11/include/smpi/smpi.h000644 001750 001750 00000120532 12342443646 015553 0ustar00cici000000 000000 /* Copyright (c) 2007-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef SMPI_H #define SMPI_H #include #include #include #include #include #ifdef _WIN32 #define MPI_CALL(type,name,args) \ type name args; \ type P##name args #else #define MPI_CALL(type,name,args) \ type name args __attribute__((weak)); \ type P##name args #endif SG_BEGIN_DECL() #define MPI_THREAD_SINGLE 0 #define MPI_THREAD_FUNNELED 1 #define MPI_THREAD_SERIALIZED 2 #define MPI_THREAD_MULTIPLE 3 //FIXME: check values #define MPI_MAX_PROCESSOR_NAME 100 #define MPI_MAX_NAME_STRING 100 #define MPI_MAX_ERROR_STRING 100 #define MPI_MAX_DATAREP_STRIN 100 #define MPI_MAX_INFO_KEY 100 #define MPI_MAX_INFO_VAL 100 #define MPI_MAX_OBJECT_NAME 100 #define MPI_MAX_PORT_NAME 100 #define MPI_MAX_LIBRARY_VERSION_STRING 100 #define SMPI_RAND_SEED 5 #define MPI_ANY_SOURCE -555 #define MPI_BOTTOM (void *)-111 #define MPI_PROC_NULL -666 #define MPI_ANY_TAG -444 #define MPI_UNDEFINED -333 #define MPI_IN_PLACE (void *)-222 // errorcodes #define MPI_SUCCESS 0 #define MPI_ERR_COMM 1 #define MPI_ERR_ARG 2 #define MPI_ERR_TYPE 3 #define MPI_ERR_REQUEST 4 #define MPI_ERR_INTERN 5 #define MPI_ERR_COUNT 6 #define MPI_ERR_RANK 7 #define MPI_ERR_TAG 8 #define MPI_ERR_TRUNCATE 9 #define MPI_ERR_GROUP 10 #define MPI_ERR_OP 11 #define MPI_ERR_OTHER 12 #define MPI_ERR_IN_STATUS 13 #define MPI_ERR_PENDING 14 #define MPI_ERR_BUFFER 15 #define MPI_ERR_NAME 16 #define MPI_ERR_DIMS 17 #define MPI_ERR_TOPOLOGY 18 #define MPI_ERR_NO_MEM 19 #define MPI_ERRCODES_IGNORE (int *)0 #define MPI_IDENT 0 #define MPI_SIMILAR 1 #define MPI_UNEQUAL 2 #define MPI_CONGRUENT 3 #define MPI_WTIME_IS_GLOBAL 1 #define MPI_TAG_UB 1000000 #define MPI_HOST 0 #define MPI_IO 0 #define MPI_BSEND_OVERHEAD 0 #define MPI_KEYVAL_INVALID 0 #define MPI_NULL_COPY_FN NULL #define MPI_NULL_DELETE_FN NULL #define MPI_APPNUM 0 #define MPI_LASTUSEDCODE MPI_SUCCESS #define MPI_ERR_LASTCODE MPI_SUCCESS #define MPI_CXX_BOOL MPI_DATATYPE_NULL #define MPI_CXX_FLOAT_COMPLEX MPI_DATATYPE_NULL #define MPI_CXX_DOUBLE_COMPLEX MPI_DATATYPE_NULL #define MPI_CXX_LONG_DOUBLE_COMPLEX MPI_DATATYPE_NULL #define MPI_REAL4 MPI_DATATYPE_NULL #define MPI_REAL8 MPI_DATATYPE_NULL #define MPI_REAL16 MPI_DATATYPE_NULL #define MPI_COMPLEX8 MPI_DATATYPE_NULL #define MPI_COMPLEX16 MPI_DATATYPE_NULL #define MPI_COMPLEX32 MPI_DATATYPE_NULL #define MPI_INTEGER1 MPI_DATATYPE_NULL #define MPI_INTEGER2 MPI_DATATYPE_NULL #define MPI_INTEGER4 MPI_DATATYPE_NULL #define MPI_INTEGER8 MPI_DATATYPE_NULL #define MPI_COMPLEX MPI_DATATYPE_NULL #define MPI_DOUBLE_COMPLEX MPI_DATATYPE_NULL #define MPI_2DOUBLE_PRECISION MPI_DATATYPE_NULL #define MPI_REAL MPI_DATATYPE_NULL #define MPI_LOGICAL MPI_DATATYPE_NULL #define MPI_DOUBLE_PRECISION MPI_DATATYPE_NULL #define MPI_INTEGER MPI_DATATYPE_NULL #define MPI_DISTRIBUTE_BLOCK 0 #define MPI_DISTRIBUTE_NONE 1 #define MPI_DISTRIBUTE_CYCLIC 2 #define MPI_DISTRIBUTE_DFLT_DARG 0 #define MPI_ORDER_C 1 #define MPI_ORDER_FORTRAN 0 #define MPI_TYPECLASS_REAL 0 #define MPI_TYPECLASS_INTEGER 1 #define MPI_TYPECLASS_COMPLEX 2 #define MPI_ROOT 0 #define MPI_INFO_NULL -1 #define MPI_COMM_TYPE_SHARED 1 #define MPI_VERSION 1 #define MPI_SUBVERSION 1 #define MPI_UNWEIGHTED (int *)0 #define MPI_ARGV_NULL (char **)0 #define MPI_ARGVS_NULL (char ***)0 #define MPI_LOCK_EXCLUSIVE 1 #define MPI_LOCK_SHARED 2 typedef enum MPIR_Combiner_enum{ MPI_COMBINER_NAMED, MPI_COMBINER_DUP, MPI_COMBINER_CONTIGUOUS, MPI_COMBINER_VECTOR, MPI_COMBINER_HVECTOR_INTEGER, MPI_COMBINER_HVECTOR, MPI_COMBINER_INDEXED, MPI_COMBINER_HINDEXED_INTEGER, MPI_COMBINER_HINDEXED, MPI_COMBINER_INDEXED_BLOCK, MPI_COMBINER_STRUCT_INTEGER, MPI_COMBINER_STRUCT, MPI_COMBINER_SUBARRAY, MPI_COMBINER_DARRAY, MPI_COMBINER_F90_REAL, MPI_COMBINER_F90_COMPLEX, MPI_COMBINER_F90_INTEGER, MPI_COMBINER_RESIZED, MPI_COMBINER_HINDEXED_BLOCK }MPIR_Combiner_enum; typedef enum MPIR_Topo_type { MPI_GRAPH=1, MPI_CART=2, MPI_DIST_GRAPH=3 } MPIR_Topo_type; typedef ptrdiff_t MPI_Aint; typedef long long MPI_Offset; // To compile code that declare MPI_File variables struct s_empty { #if !defined(__GNUC__) || defined(__STRICT_ANSI__) char empty; #endif }; typedef struct s_empty *MPI_File; struct s_smpi_mpi_datatype; typedef struct s_smpi_mpi_datatype *MPI_Datatype; typedef struct { int MPI_SOURCE; int MPI_TAG; int MPI_ERROR; int count; } MPI_Status; #define MPI_STATUS_IGNORE ((MPI_Status*)NULL) #define MPI_STATUSES_IGNORE ((MPI_Status*)NULL) #define MPI_DATATYPE_NULL ((MPI_Datatype)NULL) XBT_PUBLIC_DATA( MPI_Datatype ) MPI_CHAR; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_SHORT; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_INT; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_LONG; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_LONG_LONG; #define MPI_LONG_LONG_INT MPI_LONG_LONG XBT_PUBLIC_DATA( MPI_Datatype ) MPI_SIGNED_CHAR; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_UNSIGNED_CHAR; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_UNSIGNED_SHORT; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_UNSIGNED; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_UNSIGNED_LONG; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_UNSIGNED_LONG_LONG; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_FLOAT; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_DOUBLE; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_LONG_DOUBLE; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_WCHAR; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_C_BOOL; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_INT8_T; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_INT16_T; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_INT32_T; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_INT64_T; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_UINT8_T; #define MPI_BYTE MPI_UINT8_T XBT_PUBLIC_DATA( MPI_Datatype ) MPI_UINT16_T; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_UINT32_T; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_UINT64_T; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_C_FLOAT_COMPLEX; #define MPI_C_COMPLEX MPI_C_FLOAT_COMPLEX XBT_PUBLIC_DATA( MPI_Datatype ) MPI_C_DOUBLE_COMPLEX; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_C_LONG_DOUBLE_COMPLEX; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_AINT; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_OFFSET; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_LB; XBT_PUBLIC_DATA( MPI_Datatype ) MPI_UB; //The following are datatypes for the MPI functions MPI_MAXLOC and MPI_MINLOC. XBT_PUBLIC_DATA(MPI_Datatype) MPI_FLOAT_INT; XBT_PUBLIC_DATA(MPI_Datatype) MPI_LONG_INT; XBT_PUBLIC_DATA(MPI_Datatype) MPI_DOUBLE_INT; XBT_PUBLIC_DATA(MPI_Datatype) MPI_SHORT_INT; XBT_PUBLIC_DATA(MPI_Datatype) MPI_2INT; XBT_PUBLIC_DATA(MPI_Datatype) MPI_LONG_DOUBLE_INT; XBT_PUBLIC_DATA(MPI_Datatype) MPI_2FLOAT; XBT_PUBLIC_DATA(MPI_Datatype) MPI_2DOUBLE; //for now we only send int values at max #define MPI_Count int #define MPI_COUNT MPI_INT typedef void MPI_User_function(void *invec, void *inoutvec, int *len, MPI_Datatype * datatype); struct s_smpi_mpi_op; typedef struct s_smpi_mpi_op *MPI_Op; #define MPI_OP_NULL ((MPI_Op)NULL) XBT_PUBLIC_DATA( MPI_Op ) MPI_MAX; XBT_PUBLIC_DATA( MPI_Op ) MPI_MIN; XBT_PUBLIC_DATA( MPI_Op ) MPI_MAXLOC; XBT_PUBLIC_DATA( MPI_Op ) MPI_MINLOC; XBT_PUBLIC_DATA( MPI_Op ) MPI_SUM; XBT_PUBLIC_DATA( MPI_Op ) MPI_PROD; XBT_PUBLIC_DATA( MPI_Op ) MPI_LAND; XBT_PUBLIC_DATA( MPI_Op ) MPI_LOR; XBT_PUBLIC_DATA( MPI_Op ) MPI_LXOR; XBT_PUBLIC_DATA( MPI_Op ) MPI_BAND; XBT_PUBLIC_DATA( MPI_Op ) MPI_BOR; XBT_PUBLIC_DATA( MPI_Op ) MPI_BXOR; struct s_smpi_mpi_topology; typedef struct s_smpi_mpi_topology *MPI_Topology; struct s_smpi_mpi_group; typedef struct s_smpi_mpi_group *MPI_Group; #define MPI_GROUP_NULL ((MPI_Group)NULL) XBT_PUBLIC_DATA( MPI_Group ) MPI_GROUP_EMPTY; struct s_smpi_mpi_communicator; typedef struct s_smpi_mpi_communicator *MPI_Comm; #define MPI_COMM_NULL ((MPI_Comm)NULL) XBT_PUBLIC_DATA( MPI_Comm ) MPI_COMM_WORLD; XBT_PUBLIC_DATA( int ) MPI_UNIVERSE_SIZE; #define MPI_COMM_SELF smpi_process_comm_self() struct s_smpi_mpi_request; typedef struct s_smpi_mpi_request *MPI_Request; #define MPI_REQUEST_NULL ((MPI_Request)NULL) #define MPI_FORTRAN_REQUEST_NULL -1 MPI_CALL(XBT_PUBLIC(int), MPI_Init, (int *argc, char ***argv)); MPI_CALL(XBT_PUBLIC(int), MPI_Finalize, (void)); MPI_CALL(XBT_PUBLIC(int), MPI_Finalized, (int* flag)); MPI_CALL(XBT_PUBLIC(int), MPI_Init_thread, (int *argc, char ***argv, int required, int *provided)); MPI_CALL(XBT_PUBLIC(int), MPI_Query_thread, (int *provided)); MPI_CALL(XBT_PUBLIC(int), MPI_Is_thread_main, (int *flag)); MPI_CALL(XBT_PUBLIC(int), MPI_Abort, (MPI_Comm comm, int errorcode)); MPI_CALL(XBT_PUBLIC(double), MPI_Wtime, (void)); MPI_CALL(XBT_PUBLIC(double), MPI_Wtick,(void)); MPI_CALL(XBT_PUBLIC(int), MPI_Address, (void *location, MPI_Aint * address)); MPI_CALL(XBT_PUBLIC(int), MPI_Get_address, (void *location, MPI_Aint * address)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_free, (MPI_Datatype * datatype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_size, (MPI_Datatype datatype, int *size)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_get_extent, (MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_get_true_extent, (MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_extent, (MPI_Datatype datatype, MPI_Aint * extent)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_lb, (MPI_Datatype datatype, MPI_Aint * disp)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_ub, (MPI_Datatype datatype, MPI_Aint * disp)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_commit, (MPI_Datatype* datatype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_hindexed, (int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_hindexed, (int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_hindexed_block, (int count, int blocklength, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_hvector, (int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_hvector, (int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_indexed, (int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_indexed, (int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_indexed_block, (int count, int blocklength, int* indices, MPI_Datatype old_type, MPI_Datatype* newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_struct, (int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_struct, (int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_vector, (int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_contiguous, (int count, MPI_Datatype old_type, MPI_Datatype* newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Testall, (int count, MPI_Request* requests, int* flag, MPI_Status* statuses)); MPI_CALL(XBT_PUBLIC(int), MPI_Op_create, (MPI_User_function * function, int commute, MPI_Op * op)); MPI_CALL(XBT_PUBLIC(int), MPI_Op_free, (MPI_Op * op)); MPI_CALL(XBT_PUBLIC(int), MPI_Group_free, (MPI_Group * group)); MPI_CALL(XBT_PUBLIC(int), MPI_Group_size, (MPI_Group group, int *size)); MPI_CALL(XBT_PUBLIC(int), MPI_Group_rank, (MPI_Group group, int *rank)); MPI_CALL(XBT_PUBLIC(int), MPI_Group_translate_ranks, (MPI_Group group1, int n, int *ranks1, MPI_Group group2, int *ranks2)); MPI_CALL(XBT_PUBLIC(int), MPI_Group_compare, (MPI_Group group1, MPI_Group group2, int *result)); MPI_CALL(XBT_PUBLIC(int), MPI_Group_union, (MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)); MPI_CALL(XBT_PUBLIC(int), MPI_Group_intersection, (MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)); MPI_CALL(XBT_PUBLIC(int), MPI_Group_difference, (MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)); MPI_CALL(XBT_PUBLIC(int), MPI_Group_incl, (MPI_Group group, int n, int *ranks, MPI_Group * newgroup)); MPI_CALL(XBT_PUBLIC(int), MPI_Group_excl, (MPI_Group group, int n, int *ranks, MPI_Group * newgroup)); MPI_CALL(XBT_PUBLIC(int), MPI_Group_range_incl, (MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup)); MPI_CALL(XBT_PUBLIC(int), MPI_Group_range_excl, (MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_rank, (MPI_Comm comm, int *rank)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_size, (MPI_Comm comm, int *size)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_get_name, (MPI_Comm comm, char* name, int* len)); MPI_CALL(XBT_PUBLIC(int), MPI_Get_processor_name, (char *name, int *resultlen)); MPI_CALL(XBT_PUBLIC(int), MPI_Get_count, (MPI_Status * status, MPI_Datatype datatype, int *count)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_group, (MPI_Comm comm, MPI_Group * group)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_compare, (MPI_Comm comm1, MPI_Comm comm2, int *result)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_create, (MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_free, (MPI_Comm * comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_disconnect, (MPI_Comm * comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_split, (MPI_Comm comm, int color, int key, MPI_Comm* comm_out)); MPI_CALL(XBT_PUBLIC(int), MPI_Send_init, (void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request * request)); MPI_CALL(XBT_PUBLIC(int), MPI_Recv_init, (void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request * request)); MPI_CALL(XBT_PUBLIC(int), MPI_Start, (MPI_Request * request)); MPI_CALL(XBT_PUBLIC(int), MPI_Startall, (int count, MPI_Request * requests)); MPI_CALL(XBT_PUBLIC(int), MPI_Request_free, (MPI_Request * request)); MPI_CALL(XBT_PUBLIC(int), MPI_Irecv, (void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request * request)); MPI_CALL(XBT_PUBLIC(int), MPI_Isend, (void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request * request)); MPI_CALL(XBT_PUBLIC(int), MPI_Recv, (void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Status * status)); MPI_CALL(XBT_PUBLIC(int), MPI_Send, (void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Sendrecv, (void *sendbuf, int sendcount, MPI_Datatype sendtype, int dst, int sendtag, void *recvbuf, int recvcount, MPI_Datatype recvtype, int src, int recvtag, MPI_Comm comm, MPI_Status * status)); MPI_CALL(XBT_PUBLIC(int), MPI_Sendrecv_replace, (void *buf, int count, MPI_Datatype datatype, int dst, int sendtag, int src, int recvtag, MPI_Comm comm, MPI_Status * status)); MPI_CALL(XBT_PUBLIC(int), MPI_Test, (MPI_Request * request, int *flag, MPI_Status* status)); MPI_CALL(XBT_PUBLIC(int), MPI_Testany, (int count, MPI_Request requests[], int *index, int *flag, MPI_Status * status)); MPI_CALL(XBT_PUBLIC(int), MPI_Wait, (MPI_Request * request, MPI_Status * status)); MPI_CALL(XBT_PUBLIC(int), MPI_Waitany, (int count, MPI_Request requests[], int *index, MPI_Status * status)); MPI_CALL(XBT_PUBLIC(int), MPI_Waitall, (int count, MPI_Request requests[], MPI_Status status[])); MPI_CALL(XBT_PUBLIC(int), MPI_Waitsome, (int incount, MPI_Request requests[], int *outcount, int *indices, MPI_Status status[])); MPI_CALL(XBT_PUBLIC(int), MPI_Testsome, (int incount, MPI_Request requests[], int *outcount, int *indices, MPI_Status status[])); MPI_CALL(XBT_PUBLIC(int), MPI_Bcast, (void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Barrier, (MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Gather, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Gatherv, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int *recvcounts, int *displs, MPI_Datatype recvtype, int root, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Allgather, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Allgatherv, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int *recvcounts, int *displs, MPI_Datatype recvtype, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Scatter, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Scatterv, (void *sendbuf, int *sendcounts, int *displs, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Reduce, (void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Allreduce, (void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Scan, (void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Reduce_scatter, (void *sendbuf, void *recvbuf, int *recvcounts, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Reduce_scatter_block, (void *sendbuf, void *recvbuf, int recvcount, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Alltoall, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Alltoallv, (void *sendbuf, int *sendcounts, int *senddisps, MPI_Datatype sendtype, void *recvbuf, int *recvcounts, int *recvdisps, MPI_Datatype recvtype, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Iprobe, (int source, int tag, MPI_Comm comm, int* flag, MPI_Status* status)); MPI_CALL(XBT_PUBLIC(int), MPI_Probe, (int source, int tag, MPI_Comm comm, MPI_Status* status)); MPI_CALL(XBT_PUBLIC(int), MPI_Get_version, (int *version,int *subversion)); MPI_CALL(XBT_PUBLIC(int), MPI_Get_library_version, (char *version,int *len)); MPI_CALL(XBT_PUBLIC(int), MPI_Reduce_local,(void *inbuf, void *inoutbuf, int count, MPI_Datatype datatype, MPI_Op op)); //FIXME: these are not yet implemented typedef void MPI_Handler_function(MPI_Comm*, int*, ...); typedef int MPI_Win; typedef int MPI_Info; typedef void* MPI_Errhandler; typedef int MPI_Copy_function(MPI_Comm oldcomm, int keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, int* flag); typedef int MPI_Delete_function(MPI_Comm comm, int keyval, void* attribute_val, void* extra_state); typedef int MPI_Comm_copy_attr_function(MPI_Comm oldcomm, int keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, int* flag); typedef int MPI_Comm_delete_attr_function(MPI_Comm comm, int keyval, void* attribute_val, void* extra_state); typedef int MPI_Type_copy_attr_function(MPI_Datatype type, int keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, int* flag); typedef int MPI_Type_delete_attr_function(MPI_Datatype type, int keyval, void* attribute_val, void* extra_state); typedef void MPI_Comm_errhandler_function(MPI_Comm *, int *, ...); typedef int MPI_Grequest_query_function(void *extra_state, MPI_Status *status); typedef int MPI_Grequest_free_function(void *extra_state); typedef int MPI_Grequest_cancel_function(void *extra_state, int complete); #define MPI_DUP_FN MPI_Comm_dup #define MPI_COMM_NULL_COPY_FN ((MPI_Comm_copy_attr_function*)0) #define MPI_COMM_NULL_DELETE_FN ((MPI_Comm_delete_attr_function*)0) #define MPI_COMM_DUP_FN ((MPI_Comm_copy_attr_function *)MPI_DUP_FN) #define MPI_TYPE_NULL_COPY_FN ((MPI_Type_copy_attr_function*)0) #define MPI_TYPE_NULL_DELETE_FN ((MPI_Type_delete_attr_function*)0) #define MPI_TYPE_DUP_FN ((MPI_Type_copy_attr_function*)MPI_DUP_FN) typedef MPI_Comm_errhandler_function MPI_Comm_errhandler_fn; #define MPI_INFO_ENV 1 XBT_PUBLIC_DATA(MPI_Datatype) MPI_PACKED; XBT_PUBLIC_DATA(MPI_Errhandler*) MPI_ERRORS_RETURN; XBT_PUBLIC_DATA(MPI_Errhandler*) MPI_ERRORS_ARE_FATAL; XBT_PUBLIC_DATA(MPI_Errhandler*) MPI_ERRHANDLER_NULL; MPI_CALL(XBT_PUBLIC(int), MPI_Pack_size, (int incount, MPI_Datatype datatype, MPI_Comm comm, int* size)); MPI_CALL(XBT_PUBLIC(int), MPI_Cart_coords, (MPI_Comm comm, int rank, int maxdims, int* coords)); MPI_CALL(XBT_PUBLIC(int), MPI_Cart_create, (MPI_Comm comm_old, int ndims, int* dims, int* periods, int reorder, MPI_Comm* comm_cart)); MPI_CALL(XBT_PUBLIC(int), MPI_Cart_get, (MPI_Comm comm, int maxdims, int* dims, int* periods, int* coords)); MPI_CALL(XBT_PUBLIC(int), MPI_Cart_map, (MPI_Comm comm_old, int ndims, int* dims, int* periods, int* newrank)); MPI_CALL(XBT_PUBLIC(int), MPI_Cart_rank, (MPI_Comm comm, int* coords, int* rank)); MPI_CALL(XBT_PUBLIC(int), MPI_Cart_shift, (MPI_Comm comm, int direction, int displ, int* source, int* dest)); MPI_CALL(XBT_PUBLIC(int), MPI_Cart_sub, (MPI_Comm comm, int* remain_dims, MPI_Comm* comm_new)); MPI_CALL(XBT_PUBLIC(int), MPI_Cartdim_get, (MPI_Comm comm, int* ndims)); MPI_CALL(XBT_PUBLIC(int), MPI_Graph_create, (MPI_Comm comm_old, int nnodes, int* index, int* edges, int reorder, MPI_Comm* comm_graph)); MPI_CALL(XBT_PUBLIC(int), MPI_Graph_get, (MPI_Comm comm, int maxindex, int maxedges, int* index, int* edges)); MPI_CALL(XBT_PUBLIC(int), MPI_Graph_map, (MPI_Comm comm_old, int nnodes, int* index, int* edges, int* newrank)); MPI_CALL(XBT_PUBLIC(int), MPI_Graph_neighbors, (MPI_Comm comm, int rank, int maxneighbors, int* neighbors)); MPI_CALL(XBT_PUBLIC(int), MPI_Graph_neighbors_count, (MPI_Comm comm, int rank, int* nneighbors)); MPI_CALL(XBT_PUBLIC(int), MPI_Graphdims_get, (MPI_Comm comm, int* nnodes, int* nedges)); MPI_CALL(XBT_PUBLIC(int), MPI_Topo_test, (MPI_Comm comm, int* top_type)); MPI_CALL(XBT_PUBLIC(int), MPI_Error_class, (int errorcode, int* errorclass)); MPI_CALL(XBT_PUBLIC(int), MPI_Errhandler_create, (MPI_Handler_function* function, MPI_Errhandler* errhandler)); MPI_CALL(XBT_PUBLIC(int), MPI_Errhandler_free, (MPI_Errhandler* errhandler)); MPI_CALL(XBT_PUBLIC(int), MPI_Errhandler_get, (MPI_Comm comm, MPI_Errhandler* errhandler)); MPI_CALL(XBT_PUBLIC(int), MPI_Error_string, (int errorcode, char* string, int* resultlen)); MPI_CALL(XBT_PUBLIC(int), MPI_Errhandler_set, (MPI_Comm comm, MPI_Errhandler errhandler)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_set_errhandler, (MPI_Comm comm, MPI_Errhandler errhandler)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_get_errhandler, (MPI_Comm comm, MPI_Errhandler *errhandler)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_create_errhandler,( MPI_Comm_errhandler_fn *function, MPI_Errhandler *errhandler)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_call_errhandler,(MPI_Comm comm,int errorcode)); MPI_CALL(XBT_PUBLIC(int), MPI_Add_error_class,( int *errorclass)); MPI_CALL(XBT_PUBLIC(int), MPI_Add_error_code,( int errorclass, int *errorcode)); MPI_CALL(XBT_PUBLIC(int), MPI_Add_error_string,( int errorcode, char *string)); MPI_CALL(XBT_PUBLIC(int), MPI_Cancel, (MPI_Request* request)); MPI_CALL(XBT_PUBLIC(int), MPI_Buffer_attach, (void* buffer, int size)); MPI_CALL(XBT_PUBLIC(int), MPI_Buffer_detach, (void* buffer, int* size)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_test_inter, (MPI_Comm comm, int* flag)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_get_attr, (MPI_Comm comm, int comm_keyval, void *attribute_val, int *flag)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_set_attr, (MPI_Comm comm, int comm_keyval, void *attribute_val)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_delete_attr, (MPI_Comm comm, int comm_keyval)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_create_keyval,(MPI_Comm_copy_attr_function* copy_fn, MPI_Comm_delete_attr_function* delete_fn, int* keyval, void* extra_state)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_free_keyval,(int* keyval)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_get_attr, (MPI_Datatype type, int type_keyval, void *attribute_val, int* flag)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_set_attr, (MPI_Datatype type, int type_keyval, void *att)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_delete_attr, (MPI_Datatype type, int comm_keyval)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_keyval,(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval, void* extra_state)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_free_keyval,(int* keyval)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_dup,(MPI_Datatype datatype,MPI_Datatype *newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_set_name,(MPI_Datatype datatype, char * name)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_get_name,(MPI_Datatype datatype, char * name, int* len)); MPI_CALL(XBT_PUBLIC(int), MPI_Unpack, (void* inbuf, int insize, int* position, void* outbuf, int outcount, MPI_Datatype type, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Ssend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Ssend_init, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request)); MPI_CALL(XBT_PUBLIC(int), MPI_Intercomm_create, (MPI_Comm local_comm, int local_leader, MPI_Comm peer_comm, int remote_leader, int tag, MPI_Comm* comm_out)); MPI_CALL(XBT_PUBLIC(int), MPI_Intercomm_merge, (MPI_Comm comm, int high, MPI_Comm* comm_out)); MPI_CALL(XBT_PUBLIC(int), MPI_Bsend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Bsend_init, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request)); MPI_CALL(XBT_PUBLIC(int), MPI_Ibsend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_remote_group, (MPI_Comm comm, MPI_Group* group)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_remote_size, (MPI_Comm comm, int* size)); MPI_CALL(XBT_PUBLIC(int), MPI_Issend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request)); MPI_CALL(XBT_PUBLIC(int), MPI_Attr_delete, (MPI_Comm comm, int keyval)); MPI_CALL(XBT_PUBLIC(int), MPI_Attr_get, (MPI_Comm comm, int keyval, void* attr_value, int* flag)); MPI_CALL(XBT_PUBLIC(int), MPI_Attr_put, (MPI_Comm comm, int keyval, void* attr_value)); MPI_CALL(XBT_PUBLIC(int), MPI_Rsend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Rsend_init, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request)); MPI_CALL(XBT_PUBLIC(int), MPI_Irsend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request)); MPI_CALL(XBT_PUBLIC(int), MPI_Keyval_create, (MPI_Copy_function* copy_fn, MPI_Delete_function* delete_fn, int* keyval, void* extra_state)); MPI_CALL(XBT_PUBLIC(int), MPI_Keyval_free, (int* keyval)); MPI_CALL(XBT_PUBLIC(int), MPI_Test_cancelled, (MPI_Status* status, int* flag)); MPI_CALL(XBT_PUBLIC(int), MPI_Pack, (void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount, int* position, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Get_elements, (MPI_Status* status, MPI_Datatype datatype, int* elements)); MPI_CALL(XBT_PUBLIC(int), MPI_Dims_create, (int nnodes, int ndims, int* dims)); MPI_CALL(XBT_PUBLIC(int), MPI_Initialized, (int* flag)); MPI_CALL(XBT_PUBLIC(int), MPI_Pcontrol, (const int level )); MPI_CALL(XBT_PUBLIC(int), MPI_Win_fence,( int assert, MPI_Win win)); MPI_CALL(XBT_PUBLIC(int), MPI_Win_free,( MPI_Win* win)); MPI_CALL(XBT_PUBLIC(int), MPI_Win_create,( void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win *win)); MPI_CALL(XBT_PUBLIC(int), MPI_Info_create,( MPI_Info *info)); MPI_CALL(XBT_PUBLIC(int), MPI_Info_set,( MPI_Info info, char *key, char *value)); MPI_CALL(XBT_PUBLIC(int), MPI_Info_get,(MPI_Info info,char *key,int valuelen, char *value, int *flag)); MPI_CALL(XBT_PUBLIC(int), MPI_Info_free,( MPI_Info *info)); MPI_CALL(XBT_PUBLIC(int), MPI_Info_delete,( MPI_Info info, char *key)); MPI_CALL(XBT_PUBLIC(int), MPI_Info_dup,(MPI_Info info, MPI_Info *newinfo)); MPI_CALL(XBT_PUBLIC(int), MPI_Info_get_nkeys,( MPI_Info info, int *nkeys)); MPI_CALL(XBT_PUBLIC(int), MPI_Info_get_nthkey,( MPI_Info info, int n, char *key)); MPI_CALL(XBT_PUBLIC(int), MPI_Info_get_valuelen,( MPI_Info info, char *key, int *valuelen, int *flag)); MPI_CALL(XBT_PUBLIC(int), MPI_Get,( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_get_envelope,(MPI_Datatype datatype,int *num_integers,int *num_addresses,int *num_datatypes, int *combiner)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_get_contents,(MPI_Datatype datatype, int max_integers, int max_addresses, int max_datatypes, int* array_of_integers, MPI_Aint* array_of_addresses, MPI_Datatype *array_of_datatypes)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_darray,(int size, int rank, int ndims, int* array_of_gsizes, int* array_of_distribs, int* array_of_dargs, int* array_of_psizes, int order, MPI_Datatype oldtype, MPI_Datatype *newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Pack_external_size, (char *datarep, int incount, MPI_Datatype datatype, MPI_Aint *size)); MPI_CALL(XBT_PUBLIC(int), MPI_Pack_external, (char *datarep, void *inbuf, int incount, MPI_Datatype datatype, void *outbuf, MPI_Aint outcount, MPI_Aint *position)); MPI_CALL(XBT_PUBLIC(int), MPI_Unpack_external, ( char *datarep, void *inbuf, MPI_Aint insize, MPI_Aint *position, void *outbuf, int outcount, MPI_Datatype datatype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_resized ,(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_subarray,(int ndims,int *array_of_sizes, int *array_of_subsizes, int *array_of_starts, int order, MPI_Datatype oldtype, MPI_Datatype *newtype)); MPI_CALL(XBT_PUBLIC(int), MPI_Type_match_size,(int typeclass,int size,MPI_Datatype *datatype)); MPI_CALL(XBT_PUBLIC(int), MPI_Alltoallw, ( void *sendbuf, int *sendcnts, int *sdispls, MPI_Datatype *sendtypes, void *recvbuf, int *recvcnts, int *rdispls, MPI_Datatype *recvtypes, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Exscan,(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_set_name, (MPI_Comm comm, char* name)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_set_info, (MPI_Comm comm, MPI_Info info)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_get_info, (MPI_Comm comm, MPI_Info* info)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_dup, (MPI_Comm comm, MPI_Comm * newcomm)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_dup_with_info,(MPI_Comm comm, MPI_Info info, MPI_Comm * newcomm)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_split_type,(MPI_Comm comm, int split_type, int key, MPI_Info info, MPI_Comm *newcomm)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_connect,( char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm)); MPI_CALL(XBT_PUBLIC(int), MPI_Request_get_status,( MPI_Request request, int *flag, MPI_Status *status)); MPI_CALL(XBT_PUBLIC(int), MPI_Grequest_start,( MPI_Grequest_query_function *query_fn, MPI_Grequest_free_function *free_fn, MPI_Grequest_cancel_function *cancel_fn, void *extra_state, MPI_Request *request)); MPI_CALL(XBT_PUBLIC(int), MPI_Grequest_complete,( MPI_Request request)); MPI_CALL(XBT_PUBLIC(int), MPI_Status_set_cancelled,(MPI_Status *status,int flag)); MPI_CALL(XBT_PUBLIC(int), MPI_Status_set_elements,( MPI_Status *status, MPI_Datatype datatype, int count)); MPI_CALL(XBT_PUBLIC(int), MPI_Unpublish_name,( char *service_name, MPI_Info info, char *port_name)); MPI_CALL(XBT_PUBLIC(int), MPI_Publish_name,( char *service_name, MPI_Info info, char *port_name)); MPI_CALL(XBT_PUBLIC(int), MPI_Lookup_name,( char *service_name, MPI_Info info, char *port_name)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_join,( int fd, MPI_Comm *intercomm)); MPI_CALL(XBT_PUBLIC(int), MPI_Open_port,( MPI_Info info, char *port_name)); MPI_CALL(XBT_PUBLIC(int), MPI_Close_port,( char *port_name)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_accept,( char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_spawn,( char *command, char **argv, int maxprocs, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *intercomm, int* array_of_errcodes)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_spawn_multiple,( int count, char **array_of_commands, char*** array_of_argv, int* array_of_maxprocs, MPI_Info* array_of_info, int root, MPI_Comm comm, MPI_Comm *intercomm, int* array_of_errcodes)); MPI_CALL(XBT_PUBLIC(int), MPI_Comm_get_parent,( MPI_Comm *parent)); //FIXME: End of all the not yet implemented stuff // smpi functions XBT_PUBLIC(int) smpi_global_size(void); XBT_PUBLIC(MPI_Comm) smpi_process_comm_self(void); /* XBT_PUBLIC(void) smpi_exit(int); */ XBT_PUBLIC(void) smpi_execute_flops(double flops); XBT_PUBLIC(void) smpi_execute(double duration); XBT_PUBLIC(double) smpi_get_host_power_peak_at(int pstate_index); XBT_PUBLIC(double) smpi_get_host_current_power_peak(void); XBT_PUBLIC(int) smpi_get_host_nb_pstates(void); XBT_PUBLIC(void) smpi_set_host_power_peak_at(int pstate_index); XBT_PUBLIC(double) smpi_get_host_consumed_energy(void); XBT_PUBLIC(int) smpi_usleep(useconds_t usecs); XBT_PUBLIC(unsigned int) smpi_sleep(unsigned int secs); XBT_PUBLIC(int) smpi_gettimeofday(struct timeval *tv, void* tz); XBT_PUBLIC(unsigned long long) smpi_rastro_resolution (void); XBT_PUBLIC(unsigned long long) smpi_rastro_timestamp (void); XBT_PUBLIC(void) smpi_sample_1(int global, const char *file, int line, int iters, double threshold); XBT_PUBLIC(int) smpi_sample_2(int global, const char *file, int line); XBT_PUBLIC(void) smpi_sample_3(int global, const char *file, int line); #define SMPI_SAMPLE_LOCAL(iters,thres) for(smpi_sample_1(0, __FILE__, __LINE__, iters, thres); \ smpi_sample_2(0, __FILE__, __LINE__); \ smpi_sample_3(0, __FILE__, __LINE__)) #define SMPI_SAMPLE_GLOBAL(iters,thres) for(smpi_sample_1(1, __FILE__, __LINE__, iters, thres); \ smpi_sample_2(1, __FILE__, __LINE__); \ smpi_sample_3(1, __FILE__, __LINE__)) #define SMPI_SAMPLE_DELAY(duration) for(smpi_execute(duration); 0; ) #define SMPI_SAMPLE_FLOPS(flops) for(smpi_execute_flops(flops); 0; ) XBT_PUBLIC(void *) smpi_shared_malloc(size_t size, const char *file, int line); #define SMPI_SHARED_MALLOC(size) smpi_shared_malloc(size, __FILE__, __LINE__) XBT_PUBLIC(void) smpi_shared_free(void *data); #define SMPI_SHARED_FREE(data) smpi_shared_free(data) XBT_PUBLIC(int) smpi_shared_known_call(const char* func, const char* input); XBT_PUBLIC(void*) smpi_shared_get_call(const char* func, const char* input); XBT_PUBLIC(void*) smpi_shared_set_call(const char* func, const char* input, void* data); #define SMPI_SHARED_CALL(func, input, ...) \ (smpi_shared_known_call(#func, input) ? smpi_shared_get_call(#func, input) \ : smpi_shared_set_call(#func, input, (func(__VA_ARGS__)))) /* Fortran specific stuff */ XBT_PUBLIC(int) __attribute__((weak)) smpi_simulated_main_(int argc, char** argv); XBT_PUBLIC(int) __attribute__((weak)) MAIN__(void); XBT_PUBLIC(int) smpi_main(int (*realmain) (int argc, char *argv[]),int argc, char *argv[]); XBT_PUBLIC(void) __attribute__((weak)) user_main_(void); XBT_PUBLIC(int) smpi_process_index(void); XBT_PUBLIC(void) smpi_process_init(int *argc, char ***argv); /* Trace replay specific stuff */ XBT_PUBLIC(void) smpi_replay_init(int *argc, char***argv); XBT_PUBLIC(void) smpi_action_trace_run(char *); XBT_PUBLIC(int) smpi_replay_finalize(void); XBT_PUBLIC(void) SMPI_app_instance_register(const char *name, xbt_main_func_t code, int num_processes); XBT_PUBLIC(void) SMPI_init(void); XBT_PUBLIC(void) SMPI_finalize(void); SG_END_DECL() #endif SimGrid-3.11/include/smpi/smpi_main.h000644 001750 001750 00000000707 12342443646 016560 0ustar00cici000000 000000 /* Copyright (c) 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #define main smpi_windows_main__(int argc, char **argv);\ int main(int argc, char **argv){\ smpi_main(&smpi_windows_main__,argc,argv);\ return 0;\ }\ int smpi_windows_main__ SimGrid-3.11/include/simdag/000755 001750 001750 00000000000 12342443646 014723 5ustar00cici000000 000000 SimGrid-3.11/include/simdag/simdag.h000644 001750 001750 00000027266 12342443646 016355 0ustar00cici000000 000000 /* Copyright (c) 2006-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef SIMDAG_SIMDAG_H #define SIMDAG_SIMDAG_H #include "simdag/datatypes.h" #include "xbt/misc.h" #include "xbt/dynar.h" #include "xbt/dict.h" SG_BEGIN_DECL() /************************** AS handling *************************************/ XBT_PUBLIC(xbt_dict_t) SD_as_router_get_properties(const char *as); XBT_PUBLIC(const char*) SD_as_router_get_property_value(const char * as, const char *name); /************************** Link handling ***********************************/ /** @defgroup SD_link_management Links * @brief Functions for managing the network links * * This section describes the functions for managing the network links. * * A link is a network node represented as a name, a current * bandwidth and a current latency. The links are created * when you call the function SD_create_environment. * * @see SD_link_t * @{ */ XBT_PUBLIC(const SD_link_t *) SD_link_get_list(void); XBT_PUBLIC(int) SD_link_get_number(void); XBT_PUBLIC(void *) SD_link_get_data(SD_link_t link); XBT_PUBLIC(void) SD_link_set_data(SD_link_t link, void *data); XBT_PUBLIC(const char *) SD_link_get_name(SD_link_t link); XBT_PUBLIC(double) SD_link_get_current_bandwidth(SD_link_t link); XBT_PUBLIC(double) SD_link_get_current_latency(SD_link_t link); XBT_PUBLIC(e_SD_link_sharing_policy_t) SD_link_get_sharing_policy(SD_link_t link); /** @} */ /************************** Workstation handling ****************************/ /** @defgroup SD_workstation_management Workstations * @brief Functions for managing the workstations * * This section describes the functions for managing the workstations. * * A workstation is a place where a task can be executed. * A workstation is represented as a physical * resource with computing capabilities and has a name. * * The workstations are created when you call the function SD_create_environment. * * @see SD_workstation_t * @{ */ XBT_PUBLIC(SD_workstation_t) SD_workstation_get_by_name(const char *name); XBT_PUBLIC(const SD_workstation_t *) SD_workstation_get_list(void); XBT_PUBLIC(int) SD_workstation_get_number(void); XBT_PUBLIC(void) SD_workstation_set_data(SD_workstation_t workstation, void *data); XBT_PUBLIC(void *) SD_workstation_get_data(SD_workstation_t workstation); XBT_PUBLIC(const char *) SD_workstation_get_name(SD_workstation_t workstation); /*property handling functions*/ XBT_PUBLIC(xbt_dict_t) SD_workstation_get_properties(SD_workstation_t workstation); XBT_PUBLIC(const char *) SD_workstation_get_property_value(SD_workstation_t workstation, const char *name); XBT_PUBLIC(void) SD_workstation_dump(SD_workstation_t ws); XBT_PUBLIC(const SD_link_t *) SD_route_get_list(SD_workstation_t src, SD_workstation_t dst); XBT_PUBLIC(int) SD_route_get_size(SD_workstation_t src, SD_workstation_t dst); XBT_PUBLIC(double) SD_workstation_get_power(SD_workstation_t workstation); XBT_PUBLIC(double) SD_workstation_get_available_power(SD_workstation_t workstation); XBT_PUBLIC(int) SD_workstation_get_cores(SD_workstation_t workstation); XBT_PUBLIC(e_SD_workstation_access_mode_t) SD_workstation_get_access_mode(SD_workstation_t workstation); XBT_PUBLIC(void) SD_workstation_set_access_mode(SD_workstation_t workstation, e_SD_workstation_access_mode_t access_mode); XBT_PUBLIC(double) SD_workstation_get_computation_time(SD_workstation_t workstation, double computation_amount); XBT_PUBLIC(double) SD_route_get_current_latency(SD_workstation_t src, SD_workstation_t dst); XBT_PUBLIC(double) SD_route_get_current_bandwidth(SD_workstation_t src, SD_workstation_t dst); XBT_PUBLIC(double) SD_route_get_communication_time(SD_workstation_t src, SD_workstation_t dst, double communication_amount); XBT_PUBLIC(SD_task_t) SD_workstation_get_current_task(SD_workstation_t workstation); XBT_PUBLIC(xbt_dict_t) SD_workstation_get_mounted_storage_list(SD_workstation_t workstation); XBT_PUBLIC(xbt_dynar_t) SD_workstation_get_attached_storage_list(SD_workstation_t workstation); XBT_PUBLIC(const char*) SD_storage_get_host(SD_storage_t storage); /** @} */ /************************** Task handling ************************************/ /** @defgroup SD_task_management Tasks * @brief Functions for managing the tasks * * This section describes the functions for managing the tasks. * * A task is some working amount that can be executed * in parallel on several workstations. A task may depend on other * tasks, this means that the task cannot start until the other tasks are done. * Each task has a \ref e_SD_task_state_t "state" indicating whether * the task is scheduled, running, done, etc. * * @see SD_task_t, SD_task_dependency_management * @{ */ XBT_PUBLIC(SD_task_t) SD_task_create(const char *name, void *data, double amount); XBT_PUBLIC(void *) SD_task_get_data(SD_task_t task); XBT_PUBLIC(void) SD_task_set_data(SD_task_t task, void *data); XBT_PUBLIC(e_SD_task_state_t) SD_task_get_state(SD_task_t task); XBT_PUBLIC(const char *) SD_task_get_name(SD_task_t task); XBT_PUBLIC(void) SD_task_set_name(SD_task_t task, const char *name); XBT_PUBLIC(void) SD_task_set_rate(SD_task_t task, double rate); XBT_PUBLIC(void) SD_task_watch(SD_task_t task, e_SD_task_state_t state); XBT_PUBLIC(void) SD_task_unwatch(SD_task_t task, e_SD_task_state_t state); XBT_PUBLIC(double) SD_task_get_amount(SD_task_t task); XBT_PUBLIC(void) SD_task_set_amount(SD_task_t task, double amount); XBT_PUBLIC(double) SD_task_get_alpha(SD_task_t task); XBT_PUBLIC(double) SD_task_get_remaining_amount(SD_task_t task); XBT_PUBLIC(double) SD_task_get_execution_time(SD_task_t task, int workstation_nb, const SD_workstation_t * workstation_list, const double *computation_amount, const double *communication_amount); XBT_PUBLIC(int) SD_task_get_kind(SD_task_t task); XBT_PUBLIC(void) SD_task_schedule(SD_task_t task, int workstation_nb, const SD_workstation_t * workstation_list, const double *computation_amount, const double *communication_amount, double rate); XBT_PUBLIC(void) SD_task_unschedule(SD_task_t task); XBT_PUBLIC(double) SD_task_get_start_time(SD_task_t task); XBT_PUBLIC(double) SD_task_get_finish_time(SD_task_t task); XBT_PUBLIC(xbt_dynar_t) SD_task_get_parents(SD_task_t task); XBT_PUBLIC(xbt_dynar_t) SD_task_get_children(SD_task_t task); XBT_PUBLIC(int) SD_task_get_workstation_count(SD_task_t task); XBT_PUBLIC(SD_workstation_t *) SD_task_get_workstation_list(SD_task_t task); XBT_PUBLIC(void) SD_task_destroy(SD_task_t task); XBT_PUBLIC(void) SD_task_dump(SD_task_t task); XBT_PUBLIC(void) SD_task_dotty(SD_task_t task, void *out_FILE); XBT_PUBLIC(SD_task_t) SD_task_create_comp_seq(const char *name, void *data, double amount); XBT_PUBLIC(SD_task_t) SD_task_create_comp_par_amdahl(const char *name, void *data, double amount, double alpha); XBT_PUBLIC(SD_task_t) SD_task_create_comm_e2e(const char *name, void *data, double amount); XBT_PUBLIC(SD_task_t) SD_task_create_comm_par_mxn_1d_block(const char *name, void *data, double amount); XBT_PUBLIC(void) SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count); XBT_PUBLIC(void) SD_task_schedulev(SD_task_t task, int count, const SD_workstation_t * list); XBT_PUBLIC(void) SD_task_schedulel(SD_task_t task, int count, ...); /** @brief A constant to use in SD_task_schedule to mean that there is no cost. * * For example, create a pure computation task (no comm) like this: * * SD_task_schedule(task, my_workstation_nb, * my_workstation_list, * my_computation_amount, * SD_TASK_SCHED_NO_COST, * my_rate); */ #define SD_SCHED_NO_COST NULL /** @} */ /** @defgroup SD_task_dependency_management Tasks dependencies * @brief Functions for managing the task dependencies * * This section describes the functions for managing the dependencies between the tasks. * * @see SD_task_management * @{ */ XBT_PUBLIC(void) SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task_t dst); XBT_PUBLIC(void) SD_task_dependency_remove(SD_task_t src, SD_task_t dst); XBT_PUBLIC(const char *) SD_task_dependency_get_name(SD_task_t src, SD_task_t dst); XBT_PUBLIC(void *) SD_task_dependency_get_data(SD_task_t src, SD_task_t dst); XBT_PUBLIC(int) SD_task_dependency_exists(SD_task_t src, SD_task_t dst); /** @} */ /************************** Global *******************************************/ /** @defgroup SD_simulation Simulation * @brief Functions for creating the environment and launching the simulation * * This section describes the functions for initialising SimDag, launching * the simulation and exiting SimDag. * * @{ */ XBT_PUBLIC(void) SD_init(int *argc, char **argv); XBT_PUBLIC(void) SD_config(const char *key, const char *value); XBT_PUBLIC(void) SD_application_reinit(void); XBT_PUBLIC(void) SD_create_environment(const char *platform_file); XBT_PUBLIC(xbt_dynar_t) SD_simulate(double how_long); XBT_PUBLIC(double) SD_get_clock(void); XBT_PUBLIC(void) SD_exit(void); XBT_PUBLIC(xbt_dynar_t) SD_daxload(const char *filename); XBT_PUBLIC(xbt_dynar_t) SD_dotload(const char *filename); XBT_PUBLIC(xbt_dynar_t) SD_PTG_dotload(const char *filename); XBT_PUBLIC(xbt_dynar_t) SD_dotload_with_sched(const char *filename); XBT_PUBLIC(void) uniq_transfer_task_name(SD_task_t task); /** @} */ #include "instr/instr.h" SG_END_DECL() #endif SimGrid-3.11/include/simdag/datatypes.h000644 001750 001750 00000007776 12342443646 017113 0ustar00cici000000 000000 /* Copyright (c) 2006, 2008-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef SIMDAG_DATATYPES_H #define SIMDAG_DATATYPES_H #include "xbt/dict.h" /** @brief Workstation datatype @ingroup SD_datatypes_management A workstation is a place where a task can be executed. A workstation is represented as a physical resource with computing capabilities and has a name. @see SD_workstation_management */ typedef xbt_dictelm_t SD_workstation_t; /** @brief Workstation access mode @ingroup SD_datatypes_management By default, a workstation resource is shared, i.e. several tasks can be executed at the same time on a workstation. The CPU power of the workstation is shared between the running tasks on the workstation. In sequential mode, only one task can use the workstation, and the other tasks wait in a FIFO. @see SD_workstation_get_access_mode(), SD_workstation_set_access_mode() */ typedef enum { SD_WORKSTATION_SHARED_ACCESS, /**< @brief Several tasks can be executed at the same time */ SD_WORKSTATION_SEQUENTIAL_ACCESS /**< @brief Only one task can be executed, the others wait in a FIFO. */ } e_SD_workstation_access_mode_t; typedef enum { SD_LINK_SHARED, SD_LINK_FATPIPE } e_SD_link_sharing_policy_t; /** @brief Link datatype @ingroup SD_datatypes_management A link is a network node represented as a name, a current bandwidth and a current latency. A route is a list of links between two workstations. @see SD_link_management */ typedef struct SD_link *SD_link_t; /** @brief Task datatype @ingroup SD_datatypes_management A task is some computing amount that can be executed in parallel on several workstations. A task may depend on other tasks, this means that the task cannot start until the other tasks are done. Each task has a \ref e_SD_task_state_t "state" indicating whether the task is scheduled, running, done, etc. @see SD_task_management */ typedef struct SD_task *SD_task_t; /** @brief Task states @ingroup SD_datatypes_management @see SD_task_management */ typedef enum { SD_NOT_SCHEDULED = 0, /**< @brief Initial state (not valid for SD_watch and SD_unwatch). */ SD_SCHEDULABLE = 0x0001, /**< @brief A task becomes SD_SCHEDULABLE as soon as its dependencies are satisfied */ SD_SCHEDULED = 0x0002, /**< @brief A task becomes SD_SCHEDULED when you call function SD_task_schedule. SD_simulate will execute it when it becomes SD_RUNNABLE. */ SD_RUNNABLE = 0x0004, /**< @brief A scheduled task becomes runnable is SD_simulate as soon as its dependencies are satisfied. */ SD_IN_FIFO = 0x0008, /**< @brief A runnable task can have to wait in a workstation fifo if the workstation is sequential */ SD_RUNNING = 0x0010, /**< @brief An SD_RUNNABLE or SD_IN_FIFO becomes SD_RUNNING when it is launched. */ SD_DONE = 0x0020, /**< @brief The task is successfully finished. */ SD_FAILED = 0x0040 /**< @brief A problem occurred during the execution of the task. */ } e_SD_task_state_t; /** @brief Task kinds @ingroup SD_datatypes_management @see SD_task_management */ typedef enum { SD_TASK_NOT_TYPED = 0, /**< @brief no specified type */ SD_TASK_COMM_E2E = 1, /**< @brief end to end communication */ SD_TASK_COMP_SEQ = 2, /**< @brief sequential computation */ SD_TASK_COMP_PAR_AMDAHL = 3, /**< @brief parallel computation (Amdahl's law) */ SD_TASK_COMM_PAR_MXN_1D_BLOCK = 4 /**< @brief MxN data redistribution (1D Block distribution) */ } e_SD_task_kind_t; /** @brief Storage datatype @ingroup SD_datatypes_management TODO PV: comment it ! @see SD_storage_management */ typedef xbt_dictelm_t SD_storage_t; #endif SimGrid-3.11/include/surf/000755 001750 001750 00000000000 12342443646 014436 5ustar00cici000000 000000 SimGrid-3.11/include/surf/surfxml_parse.h000644 001750 001750 00000006303 12342443646 017503 0ustar00cici000000 000000 /* Copyright (c) 2006-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _SURF_SURFXML_PARSE_H #define _SURF_SURFXML_PARSE_H #include /* to have FILE */ #include "xbt/misc.h" #include "xbt/function_types.h" #include "xbt/dict.h" #include "surf/simgrid_dtd.h" #ifndef YY_TYPEDEF_YY_SIZE_T #define YY_TYPEDEF_YY_SIZE_T typedef size_t yy_size_t; #endif SG_BEGIN_DECL() XBT_PUBLIC(void) surf_parse_open(const char *file); XBT_PUBLIC(void) surf_parse_close(void); XBT_PUBLIC(void) surf_parse_init_callbacks(void); XBT_PUBLIC(void) surf_parse_reset_callbacks(void); XBT_PUBLIC(void) surf_parse_free_callbacks(void); XBT_PUBLIC(void) surf_parse_error(const char *msg,...) _XBT_GNUC_PRINTF(1,2) _XBT_GNUC_NORETURN; XBT_PUBLIC(void) surf_parse_warn(const char *msg,...) _XBT_GNUC_PRINTF(1,2); XBT_PUBLIC(double) surf_parse_get_double(const char *string); XBT_PUBLIC(int) surf_parse_get_int(const char *string); XBT_PUBLIC(double) surf_parse_get_time(const char *string); XBT_PUBLIC(double) surf_parse_get_size(const char *string); XBT_PUBLIC(double) surf_parse_get_bandwidth(const char *string); XBT_PUBLIC(double) surf_parse_get_power(const char *string); /* Prototypes of the functions offered by flex */ XBT_PUBLIC(int) surf_parse_lex(void); XBT_PUBLIC(int) surf_parse_get_lineno(void); XBT_PUBLIC(FILE *) surf_parse_get_in(void); XBT_PUBLIC(FILE *) surf_parse_get_out(void); XBT_PUBLIC(yy_size_t) surf_parse_get_leng(void); XBT_PUBLIC(char *) surf_parse_get_text(void); XBT_PUBLIC(void) surf_parse_set_lineno(int line_number); XBT_PUBLIC(void) surf_parse_set_in(FILE * in_str); XBT_PUBLIC(void) surf_parse_set_out(FILE * out_str); XBT_PUBLIC(int) surf_parse_get_debug(void); XBT_PUBLIC(void) surf_parse_set_debug(int bdebug); XBT_PUBLIC(int) surf_parse_lex_destroy(void); /* What is needed to bypass the parser. */ XBT_PUBLIC_DATA(int_f_void_t) surf_parse; /* Entry-point to the parser. Set this to your function. */ /* Set of macros to make the bypassing work easier. * See examples/msg/masterslave_bypass.c for an example of use */ extern unsigned int surfxml_buffer_stack_stack_ptr; extern unsigned int surfxml_buffer_stack_stack[1024]; #define SURFXML_BUFFER_SET(key,val) do { \ AX_surfxml_##key=AX_ptr; \ strcpy(A_surfxml_##key,val); \ AX_ptr+=(int)strlen(val)+1; } while(0) #define SURFXML_BUFFER_RESET() do { \ AX_ptr = 0; \ memset(surfxml_bufferstack,0,surfxml_bufferstack_size); } while(0) #define SURFXML_START_TAG(tag) \ do{ \ surfxml_buffer_stack_stack[surfxml_buffer_stack_stack_ptr++] = AX_ptr; \ STag_surfxml_##tag(); \ }while(0) #define SURFXML_END_TAG(tag) \ do{ \ AX_ptr = surfxml_buffer_stack_stack[--surfxml_buffer_stack_stack_ptr]; \ ETag_surfxml_##tag(); \ } while(0) SG_END_DECL() #endif SimGrid-3.11/include/surf/simgrid_dtd.h000644 001750 001750 00000121155 12342443646 017105 0ustar00cici000000 000000 /* XML processor/application API for src/surf/simgrid.dtd. * * This program was generated with the FleXML XML processor generator. * FleXML is Copyright (C) 1999-2005 Kristoffer Rose. All rights reserved. * FleXML is Copyright (C) 2003-2013 Martin Quinson. All rights reserved. * (1.9.6). * * There are two, intertwined parts to this program, part A and part B. * * Part A * ------ * * Some parts, here collectively called "Part A", are found in the * FleXML package. They are Copyright (C) 1999-2005 Kristoffer Rose * and Copyright (C) 2003-2013 Martin Quinson. All rights reserved. * * You can redistribute, use, perform, display and/or modify "Part A" * provided the following two conditions hold: * * 1. The program is distributed WITHOUT ANY WARRANTY from the author of * FleXML; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. * * 2. The program distribution conditions do not in any way affect the * distribution conditions of the FleXML system used to generate this * file or any version of FleXML derived from that system. * * Notice that these are explicit rights granted to you for files * generated by the FleXML system. For your rights in connection with * the FleXML system itself please consult the GNU General Public License. * * Part B * ------ * * The other parts, here collectively called "Part B", and which came * from the DTD used by FleXML to generate this program, can be * distributed (or not, as the case may be) under the terms of whoever * wrote them, provided these terms respect and obey the two conditions * above under the heading "Part A". * * The author of and contributors to FleXML specifically disclaim * any copyright interest in "Part B", unless "Part B" was written * by the author of or contributors to FleXML. * */ #ifndef _FLEXML_simgrid_H #define _FLEXML_simgrid_H /* XML application entry points. */ XBT_PUBLIC(void) STag_surfxml_platform(void); XBT_PUBLIC(void) ETag_surfxml_platform(void); XBT_PUBLIC(void) STag_surfxml_include(void); XBT_PUBLIC(void) ETag_surfxml_include(void); XBT_PUBLIC(void) STag_surfxml_trace(void); XBT_PUBLIC(void) ETag_surfxml_trace(void); XBT_PUBLIC(void) STag_surfxml_random(void); XBT_PUBLIC(void) ETag_surfxml_random(void); XBT_PUBLIC(void) STag_surfxml_trace___connect(void); XBT_PUBLIC(void) ETag_surfxml_trace___connect(void); XBT_PUBLIC(void) STag_surfxml_AS(void); XBT_PUBLIC(void) ETag_surfxml_AS(void); XBT_PUBLIC(void) STag_surfxml_storage___type(void); XBT_PUBLIC(void) ETag_surfxml_storage___type(void); XBT_PUBLIC(void) STag_surfxml_mount(void); XBT_PUBLIC(void) ETag_surfxml_mount(void); XBT_PUBLIC(void) STag_surfxml_mstorage(void); XBT_PUBLIC(void) ETag_surfxml_mstorage(void); XBT_PUBLIC(void) STag_surfxml_host(void); XBT_PUBLIC(void) ETag_surfxml_host(void); XBT_PUBLIC(void) STag_surfxml_storage(void); XBT_PUBLIC(void) ETag_surfxml_storage(void); XBT_PUBLIC(void) STag_surfxml_gpu(void); XBT_PUBLIC(void) ETag_surfxml_gpu(void); XBT_PUBLIC(void) STag_surfxml_host___link(void); XBT_PUBLIC(void) ETag_surfxml_host___link(void); XBT_PUBLIC(void) STag_surfxml_cluster(void); XBT_PUBLIC(void) ETag_surfxml_cluster(void); XBT_PUBLIC(void) STag_surfxml_cabinet(void); XBT_PUBLIC(void) ETag_surfxml_cabinet(void); XBT_PUBLIC(void) STag_surfxml_peer(void); XBT_PUBLIC(void) ETag_surfxml_peer(void); XBT_PUBLIC(void) STag_surfxml_router(void); XBT_PUBLIC(void) ETag_surfxml_router(void); XBT_PUBLIC(void) STag_surfxml_backbone(void); XBT_PUBLIC(void) ETag_surfxml_backbone(void); XBT_PUBLIC(void) STag_surfxml_link(void); XBT_PUBLIC(void) ETag_surfxml_link(void); XBT_PUBLIC(void) STag_surfxml_route(void); XBT_PUBLIC(void) ETag_surfxml_route(void); XBT_PUBLIC(void) STag_surfxml_ASroute(void); XBT_PUBLIC(void) ETag_surfxml_ASroute(void); XBT_PUBLIC(void) STag_surfxml_link___ctn(void); XBT_PUBLIC(void) ETag_surfxml_link___ctn(void); XBT_PUBLIC(void) STag_surfxml_bypassRoute(void); XBT_PUBLIC(void) ETag_surfxml_bypassRoute(void); XBT_PUBLIC(void) STag_surfxml_bypassASroute(void); XBT_PUBLIC(void) ETag_surfxml_bypassASroute(void); XBT_PUBLIC(void) STag_surfxml_process(void); XBT_PUBLIC(void) ETag_surfxml_process(void); XBT_PUBLIC(void) STag_surfxml_argument(void); XBT_PUBLIC(void) ETag_surfxml_argument(void); XBT_PUBLIC(void) STag_surfxml_config(void); XBT_PUBLIC(void) ETag_surfxml_config(void); XBT_PUBLIC(void) STag_surfxml_prop(void); XBT_PUBLIC(void) ETag_surfxml_prop(void); XBT_PUBLIC(void) STag_surfxml_model___prop(void); XBT_PUBLIC(void) ETag_surfxml_model___prop(void); /* XML application data. */ typedef int AT_surfxml_cluster_bb___lat; #define AU_surfxml_cluster_bb___lat NULL typedef int AT_surfxml_random_max; #define AU_surfxml_random_max NULL typedef int AT_surfxml_host_availability___file; #define AU_surfxml_host_availability___file NULL typedef int AT_surfxml_ASroute_src; #define AU_surfxml_ASroute_src NULL typedef int AT_surfxml_cabinet_id; #define AU_surfxml_cabinet_id NULL typedef int AT_surfxml_cabinet_prefix; #define AU_surfxml_cabinet_prefix NULL typedef int AT_surfxml_process_function; #define AU_surfxml_process_function NULL typedef int AT_surfxml_ASroute_gw___dst; #define AU_surfxml_ASroute_gw___dst NULL typedef int AT_surfxml_storage___type_content___type; #define AU_surfxml_storage___type_content___type NULL typedef int AT_surfxml_include_file; #define AU_surfxml_include_file NULL typedef int AT_surfxml_link_bandwidth___file; #define AU_surfxml_link_bandwidth___file NULL typedef int AT_surfxml_process_kill___time; #define AU_surfxml_process_kill___time NULL typedef int AT_surfxml_link_bandwidth; #define AU_surfxml_link_bandwidth NULL typedef int AT_surfxml_trace_periodicity; #define AU_surfxml_trace_periodicity NULL typedef int AT_surfxml_storage_typeId; #define AU_surfxml_storage_typeId NULL typedef int AT_surfxml_cabinet_suffix; #define AU_surfxml_cabinet_suffix NULL typedef int AT_surfxml_link_latency___file; #define AU_surfxml_link_latency___file NULL typedef int AT_surfxml_link_id; #define AU_surfxml_link_id NULL typedef int AT_surfxml_trace_id; #define AU_surfxml_trace_id NULL typedef enum { AU_surfxml_cluster_bb___sharing___policy, A_surfxml_cluster_bb___sharing___policy_SHARED,A_surfxml_cluster_bb___sharing___policy_FATPIPE } AT_surfxml_cluster_bb___sharing___policy; typedef int AT_surfxml_cabinet_radical; #define AU_surfxml_cabinet_radical NULL typedef int AT_surfxml_cluster_lat; #define AU_surfxml_cluster_lat NULL typedef int AT_surfxml_process_host; #define AU_surfxml_process_host NULL typedef int AT_surfxml_cluster_core; #define AU_surfxml_cluster_core NULL typedef int AT_surfxml_peer_id; #define AU_surfxml_peer_id NULL typedef int AT_surfxml_storage___type_content; #define AU_surfxml_storage___type_content NULL typedef enum { AU_surfxml_link___ctn_direction, A_surfxml_link___ctn_direction_UP,A_surfxml_link___ctn_direction_DOWN,A_surfxml_link___ctn_direction_NONE } AT_surfxml_link___ctn_direction; typedef enum { AU_surfxml_random_generator, A_surfxml_random_generator_DRAND48,A_surfxml_random_generator_RAND,A_surfxml_random_generator_RNGSTREAM,A_surfxml_random_generator_NONE } AT_surfxml_random_generator; typedef int AT_surfxml_bypassRoute_dst; #define AU_surfxml_bypassRoute_dst NULL typedef int AT_surfxml_cluster_loopback___lat; #define AU_surfxml_cluster_loopback___lat NULL typedef int AT_surfxml_bypassRoute_src; #define AU_surfxml_bypassRoute_src NULL typedef int AT_surfxml_cluster_limiter___link; #define AU_surfxml_cluster_limiter___link NULL typedef int AT_surfxml_mstorage_typeId; #define AU_surfxml_mstorage_typeId NULL typedef int AT_surfxml_random_seed; #define AU_surfxml_random_seed NULL typedef int AT_surfxml_random_mean; #define AU_surfxml_random_mean NULL typedef int AT_surfxml_link___ctn_id; #define AU_surfxml_link___ctn_id NULL typedef int AT_surfxml_model___prop_value; #define AU_surfxml_model___prop_value NULL typedef int AT_surfxml_peer_bw___out; #define AU_surfxml_peer_bw___out NULL typedef int AT_surfxml_bypassASroute_src; #define AU_surfxml_bypassASroute_src NULL typedef int AT_surfxml_backbone_bandwidth; #define AU_surfxml_backbone_bandwidth NULL typedef int AT_surfxml_host___link_up; #define AU_surfxml_host___link_up NULL typedef enum { AU_surfxml_cluster_topology, A_surfxml_cluster_topology_FLAT,A_surfxml_cluster_topology_TORUS,A_surfxml_cluster_topology_FAT___TREE } AT_surfxml_cluster_topology; typedef int AT_surfxml_ASroute_gw___src; #define AU_surfxml_ASroute_gw___src NULL typedef int AT_surfxml_random_id; #define AU_surfxml_random_id NULL typedef int AT_surfxml_peer_power; #define AU_surfxml_peer_power NULL typedef enum { AU_surfxml_AS_routing, A_surfxml_AS_routing_Full,A_surfxml_AS_routing_Floyd,A_surfxml_AS_routing_Dijkstra,A_surfxml_AS_routing_DijkstraCache,A_surfxml_AS_routing_None,A_surfxml_AS_routing_Vivaldi,A_surfxml_AS_routing_Cluster,A_surfxml_AS_routing_Cluster___torus,A_surfxml_AS_routing_Cluster___fat___tree } AT_surfxml_AS_routing; typedef int AT_surfxml_process_start___time; #define AU_surfxml_process_start___time NULL typedef int AT_surfxml_cluster_topo___parameters; #define AU_surfxml_cluster_topo___parameters NULL typedef int AT_surfxml_route_dst; #define AU_surfxml_route_dst NULL typedef int AT_surfxml_host_coordinates; #define AU_surfxml_host_coordinates NULL typedef int AT_surfxml_host___link_down; #define AU_surfxml_host___link_down NULL typedef int AT_surfxml_cluster_radical; #define AU_surfxml_cluster_radical NULL typedef int AT_surfxml_config_id; #define AU_surfxml_config_id NULL typedef int AT_surfxml_cabinet_power; #define AU_surfxml_cabinet_power NULL typedef int AT_surfxml_model___prop_id; #define AU_surfxml_model___prop_id NULL typedef int AT_surfxml_peer_coordinates; #define AU_surfxml_peer_coordinates NULL typedef int AT_surfxml_mstorage_name; #define AU_surfxml_mstorage_name NULL typedef int AT_surfxml_host___link_id; #define AU_surfxml_host___link_id NULL typedef int AT_surfxml_cluster_loopback___bw; #define AU_surfxml_cluster_loopback___bw NULL typedef int AT_surfxml_cluster_suffix; #define AU_surfxml_cluster_suffix NULL typedef int AT_surfxml_cluster_router___id; #define AU_surfxml_cluster_router___id NULL typedef int AT_surfxml_prop_id; #define AU_surfxml_prop_id NULL typedef int AT_surfxml_backbone_id; #define AU_surfxml_backbone_id NULL typedef int AT_surfxml_link_state___file; #define AU_surfxml_link_state___file NULL typedef int AT_surfxml_cabinet_lat; #define AU_surfxml_cabinet_lat NULL typedef int AT_surfxml_storage___type_id; #define AU_surfxml_storage___type_id NULL typedef int AT_surfxml_storage_content___type; #define AU_surfxml_storage_content___type NULL typedef int AT_surfxml_random_radical; #define AU_surfxml_random_radical NULL typedef int AT_surfxml_cluster_power; #define AU_surfxml_cluster_power NULL typedef int AT_surfxml_trace___connect_element; #define AU_surfxml_trace___connect_element NULL typedef int AT_surfxml_link_latency; #define AU_surfxml_link_latency NULL typedef enum { AU_surfxml_host_state, A_surfxml_host_state_ON,A_surfxml_host_state_OFF } AT_surfxml_host_state; typedef int AT_surfxml_host_core; #define AU_surfxml_host_core NULL typedef int AT_surfxml_storage___type_size; #define AU_surfxml_storage___type_size NULL typedef int AT_surfxml_mount_name; #define AU_surfxml_mount_name NULL typedef int AT_surfxml_cluster_id; #define AU_surfxml_cluster_id NULL typedef int AT_surfxml_peer_state___file; #define AU_surfxml_peer_state___file NULL typedef int AT_surfxml_host_state___file; #define AU_surfxml_host_state___file NULL typedef int AT_surfxml_bypassASroute_dst; #define AU_surfxml_bypassASroute_dst NULL typedef enum { AU_surfxml_link_state, A_surfxml_link_state_ON,A_surfxml_link_state_OFF } AT_surfxml_link_state; typedef int AT_surfxml_bypassASroute_gw___dst; #define AU_surfxml_bypassASroute_gw___dst NULL typedef int AT_surfxml_random_std___deviation; #define AU_surfxml_random_std___deviation NULL typedef int AT_surfxml_cluster_bb___bw; #define AU_surfxml_cluster_bb___bw NULL typedef int AT_surfxml_trace___connect_trace; #define AU_surfxml_trace___connect_trace NULL typedef int AT_surfxml_peer_lat; #define AU_surfxml_peer_lat NULL typedef int AT_surfxml_cabinet_bw; #define AU_surfxml_cabinet_bw NULL typedef int AT_surfxml_cluster_prefix; #define AU_surfxml_cluster_prefix NULL typedef int AT_surfxml_storage_attach; #define AU_surfxml_storage_attach NULL typedef int AT_surfxml_random_min; #define AU_surfxml_random_min NULL typedef enum { AU_surfxml_trace___connect_kind, A_surfxml_trace___connect_kind_HOST___AVAIL,A_surfxml_trace___connect_kind_POWER,A_surfxml_trace___connect_kind_LINK___AVAIL,A_surfxml_trace___connect_kind_BANDWIDTH,A_surfxml_trace___connect_kind_LATENCY } AT_surfxml_trace___connect_kind; typedef int AT_surfxml_router_coordinates; #define AU_surfxml_router_coordinates NULL typedef int AT_surfxml_bypassASroute_gw___src; #define AU_surfxml_bypassASroute_gw___src NULL typedef int AT_surfxml_backbone_latency; #define AU_surfxml_backbone_latency NULL typedef int AT_surfxml_host_id; #define AU_surfxml_host_id NULL typedef int AT_surfxml_AS_id; #define AU_surfxml_AS_id NULL typedef int AT_surfxml_cluster_state___file; #define AU_surfxml_cluster_state___file NULL typedef int AT_surfxml_peer_bw___in; #define AU_surfxml_peer_bw___in NULL typedef int AT_surfxml_ASroute_dst; #define AU_surfxml_ASroute_dst NULL typedef int AT_surfxml_trace_file; #define AU_surfxml_trace_file NULL typedef int AT_surfxml_router_id; #define AU_surfxml_router_id NULL typedef int AT_surfxml_prop_value; #define AU_surfxml_prop_value NULL typedef int AT_surfxml_storage_id; #define AU_surfxml_storage_id NULL typedef int AT_surfxml_storage_content; #define AU_surfxml_storage_content NULL typedef enum { AU_surfxml_link_sharing___policy, A_surfxml_link_sharing___policy_SHARED,A_surfxml_link_sharing___policy_FATPIPE,A_surfxml_link_sharing___policy_FULLDUPLEX } AT_surfxml_link_sharing___policy; typedef enum { AU_surfxml_process_on___failure, A_surfxml_process_on___failure_DIE,A_surfxml_process_on___failure_RESTART } AT_surfxml_process_on___failure; typedef int AT_surfxml_host_power; #define AU_surfxml_host_power NULL typedef int AT_surfxml_cluster_availability___file; #define AU_surfxml_cluster_availability___file NULL typedef int AT_surfxml_platform_version; #define AU_surfxml_platform_version NULL typedef int AT_surfxml_host_availability; #define AU_surfxml_host_availability NULL typedef int AT_surfxml_mount_storageId; #define AU_surfxml_mount_storageId NULL typedef int AT_surfxml_host_pstate; #define AU_surfxml_host_pstate NULL typedef int AT_surfxml_cluster_bw; #define AU_surfxml_cluster_bw NULL typedef int AT_surfxml_argument_value; #define AU_surfxml_argument_value NULL typedef enum { AU_surfxml_route_symmetrical, A_surfxml_route_symmetrical_YES,A_surfxml_route_symmetrical_NO } AT_surfxml_route_symmetrical; typedef int AT_surfxml_route_src; #define AU_surfxml_route_src NULL typedef int AT_surfxml_peer_availability___file; #define AU_surfxml_peer_availability___file NULL typedef enum { AU_surfxml_ASroute_symmetrical, A_surfxml_ASroute_symmetrical_YES,A_surfxml_ASroute_symmetrical_NO } AT_surfxml_ASroute_symmetrical; typedef enum { AU_surfxml_cluster_sharing___policy, A_surfxml_cluster_sharing___policy_SHARED,A_surfxml_cluster_sharing___policy_FULLDUPLEX,A_surfxml_cluster_sharing___policy_FATPIPE } AT_surfxml_cluster_sharing___policy; typedef int AT_surfxml_gpu_name; #define AU_surfxml_gpu_name NULL typedef int AT_surfxml_storage___type_model; #define AU_surfxml_storage___type_model NULL /* FleXML-provided data. */ XBT_PUBLIC_DATA(int) surfxml_pcdata_ix; XBT_PUBLIC_DATA(char *) surfxml_bufferstack; #define surfxml_pcdata (surfxml_bufferstack + surfxml_pcdata_ix) XBT_PUBLIC_DATA(AT_surfxml_cluster_bb___lat) AX_surfxml_cluster_bb___lat; #define A_surfxml_cluster_bb___lat (surfxml_bufferstack + AX_surfxml_cluster_bb___lat) XBT_PUBLIC_DATA(short int) surfxml_cluster_bb___lat_isset; XBT_PUBLIC_DATA(AT_surfxml_random_max) AX_surfxml_random_max; #define A_surfxml_random_max (surfxml_bufferstack + AX_surfxml_random_max) XBT_PUBLIC_DATA(short int) surfxml_random_max_isset; XBT_PUBLIC_DATA(AT_surfxml_host_availability___file) AX_surfxml_host_availability___file; #define A_surfxml_host_availability___file (surfxml_bufferstack + AX_surfxml_host_availability___file) XBT_PUBLIC_DATA(short int) surfxml_host_availability___file_isset; XBT_PUBLIC_DATA(AT_surfxml_ASroute_src) AX_surfxml_ASroute_src; #define A_surfxml_ASroute_src (surfxml_bufferstack + AX_surfxml_ASroute_src) XBT_PUBLIC_DATA(short int) surfxml_ASroute_src_isset; XBT_PUBLIC_DATA(AT_surfxml_cabinet_id) AX_surfxml_cabinet_id; #define A_surfxml_cabinet_id (surfxml_bufferstack + AX_surfxml_cabinet_id) XBT_PUBLIC_DATA(short int) surfxml_cabinet_id_isset; XBT_PUBLIC_DATA(AT_surfxml_cabinet_prefix) AX_surfxml_cabinet_prefix; #define A_surfxml_cabinet_prefix (surfxml_bufferstack + AX_surfxml_cabinet_prefix) XBT_PUBLIC_DATA(short int) surfxml_cabinet_prefix_isset; XBT_PUBLIC_DATA(AT_surfxml_process_function) AX_surfxml_process_function; #define A_surfxml_process_function (surfxml_bufferstack + AX_surfxml_process_function) XBT_PUBLIC_DATA(short int) surfxml_process_function_isset; XBT_PUBLIC_DATA(AT_surfxml_ASroute_gw___dst) AX_surfxml_ASroute_gw___dst; #define A_surfxml_ASroute_gw___dst (surfxml_bufferstack + AX_surfxml_ASroute_gw___dst) XBT_PUBLIC_DATA(short int) surfxml_ASroute_gw___dst_isset; XBT_PUBLIC_DATA(AT_surfxml_storage___type_content___type) AX_surfxml_storage___type_content___type; #define A_surfxml_storage___type_content___type (surfxml_bufferstack + AX_surfxml_storage___type_content___type) XBT_PUBLIC_DATA(short int) surfxml_storage___type_content___type_isset; XBT_PUBLIC_DATA(AT_surfxml_include_file) AX_surfxml_include_file; #define A_surfxml_include_file (surfxml_bufferstack + AX_surfxml_include_file) XBT_PUBLIC_DATA(short int) surfxml_include_file_isset; XBT_PUBLIC_DATA(AT_surfxml_link_bandwidth___file) AX_surfxml_link_bandwidth___file; #define A_surfxml_link_bandwidth___file (surfxml_bufferstack + AX_surfxml_link_bandwidth___file) XBT_PUBLIC_DATA(short int) surfxml_link_bandwidth___file_isset; XBT_PUBLIC_DATA(AT_surfxml_process_kill___time) AX_surfxml_process_kill___time; #define A_surfxml_process_kill___time (surfxml_bufferstack + AX_surfxml_process_kill___time) XBT_PUBLIC_DATA(short int) surfxml_process_kill___time_isset; XBT_PUBLIC_DATA(AT_surfxml_link_bandwidth) AX_surfxml_link_bandwidth; #define A_surfxml_link_bandwidth (surfxml_bufferstack + AX_surfxml_link_bandwidth) XBT_PUBLIC_DATA(short int) surfxml_link_bandwidth_isset; XBT_PUBLIC_DATA(AT_surfxml_trace_periodicity) AX_surfxml_trace_periodicity; #define A_surfxml_trace_periodicity (surfxml_bufferstack + AX_surfxml_trace_periodicity) XBT_PUBLIC_DATA(short int) surfxml_trace_periodicity_isset; XBT_PUBLIC_DATA(AT_surfxml_storage_typeId) AX_surfxml_storage_typeId; #define A_surfxml_storage_typeId (surfxml_bufferstack + AX_surfxml_storage_typeId) XBT_PUBLIC_DATA(short int) surfxml_storage_typeId_isset; XBT_PUBLIC_DATA(AT_surfxml_cabinet_suffix) AX_surfxml_cabinet_suffix; #define A_surfxml_cabinet_suffix (surfxml_bufferstack + AX_surfxml_cabinet_suffix) XBT_PUBLIC_DATA(short int) surfxml_cabinet_suffix_isset; XBT_PUBLIC_DATA(AT_surfxml_link_latency___file) AX_surfxml_link_latency___file; #define A_surfxml_link_latency___file (surfxml_bufferstack + AX_surfxml_link_latency___file) XBT_PUBLIC_DATA(short int) surfxml_link_latency___file_isset; XBT_PUBLIC_DATA(AT_surfxml_link_id) AX_surfxml_link_id; #define A_surfxml_link_id (surfxml_bufferstack + AX_surfxml_link_id) XBT_PUBLIC_DATA(short int) surfxml_link_id_isset; XBT_PUBLIC_DATA(AT_surfxml_trace_id) AX_surfxml_trace_id; #define A_surfxml_trace_id (surfxml_bufferstack + AX_surfxml_trace_id) XBT_PUBLIC_DATA(short int) surfxml_trace_id_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_bb___sharing___policy) AX_surfxml_cluster_bb___sharing___policy; #define A_surfxml_cluster_bb___sharing___policy AX_surfxml_cluster_bb___sharing___policy XBT_PUBLIC_DATA(short int) surfxml_cluster_bb___sharing___policy_isset; XBT_PUBLIC_DATA(AT_surfxml_cabinet_radical) AX_surfxml_cabinet_radical; #define A_surfxml_cabinet_radical (surfxml_bufferstack + AX_surfxml_cabinet_radical) XBT_PUBLIC_DATA(short int) surfxml_cabinet_radical_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_lat) AX_surfxml_cluster_lat; #define A_surfxml_cluster_lat (surfxml_bufferstack + AX_surfxml_cluster_lat) XBT_PUBLIC_DATA(short int) surfxml_cluster_lat_isset; XBT_PUBLIC_DATA(AT_surfxml_process_host) AX_surfxml_process_host; #define A_surfxml_process_host (surfxml_bufferstack + AX_surfxml_process_host) XBT_PUBLIC_DATA(short int) surfxml_process_host_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_core) AX_surfxml_cluster_core; #define A_surfxml_cluster_core (surfxml_bufferstack + AX_surfxml_cluster_core) XBT_PUBLIC_DATA(short int) surfxml_cluster_core_isset; XBT_PUBLIC_DATA(AT_surfxml_peer_id) AX_surfxml_peer_id; #define A_surfxml_peer_id (surfxml_bufferstack + AX_surfxml_peer_id) XBT_PUBLIC_DATA(short int) surfxml_peer_id_isset; XBT_PUBLIC_DATA(AT_surfxml_storage___type_content) AX_surfxml_storage___type_content; #define A_surfxml_storage___type_content (surfxml_bufferstack + AX_surfxml_storage___type_content) XBT_PUBLIC_DATA(short int) surfxml_storage___type_content_isset; XBT_PUBLIC_DATA(AT_surfxml_link___ctn_direction) AX_surfxml_link___ctn_direction; #define A_surfxml_link___ctn_direction AX_surfxml_link___ctn_direction XBT_PUBLIC_DATA(short int) surfxml_link___ctn_direction_isset; XBT_PUBLIC_DATA(AT_surfxml_random_generator) AX_surfxml_random_generator; #define A_surfxml_random_generator AX_surfxml_random_generator XBT_PUBLIC_DATA(short int) surfxml_random_generator_isset; XBT_PUBLIC_DATA(AT_surfxml_bypassRoute_dst) AX_surfxml_bypassRoute_dst; #define A_surfxml_bypassRoute_dst (surfxml_bufferstack + AX_surfxml_bypassRoute_dst) XBT_PUBLIC_DATA(short int) surfxml_bypassRoute_dst_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_loopback___lat) AX_surfxml_cluster_loopback___lat; #define A_surfxml_cluster_loopback___lat (surfxml_bufferstack + AX_surfxml_cluster_loopback___lat) XBT_PUBLIC_DATA(short int) surfxml_cluster_loopback___lat_isset; XBT_PUBLIC_DATA(AT_surfxml_bypassRoute_src) AX_surfxml_bypassRoute_src; #define A_surfxml_bypassRoute_src (surfxml_bufferstack + AX_surfxml_bypassRoute_src) XBT_PUBLIC_DATA(short int) surfxml_bypassRoute_src_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_limiter___link) AX_surfxml_cluster_limiter___link; #define A_surfxml_cluster_limiter___link (surfxml_bufferstack + AX_surfxml_cluster_limiter___link) XBT_PUBLIC_DATA(short int) surfxml_cluster_limiter___link_isset; XBT_PUBLIC_DATA(AT_surfxml_mstorage_typeId) AX_surfxml_mstorage_typeId; #define A_surfxml_mstorage_typeId (surfxml_bufferstack + AX_surfxml_mstorage_typeId) XBT_PUBLIC_DATA(short int) surfxml_mstorage_typeId_isset; XBT_PUBLIC_DATA(AT_surfxml_random_seed) AX_surfxml_random_seed; #define A_surfxml_random_seed (surfxml_bufferstack + AX_surfxml_random_seed) XBT_PUBLIC_DATA(short int) surfxml_random_seed_isset; XBT_PUBLIC_DATA(AT_surfxml_random_mean) AX_surfxml_random_mean; #define A_surfxml_random_mean (surfxml_bufferstack + AX_surfxml_random_mean) XBT_PUBLIC_DATA(short int) surfxml_random_mean_isset; XBT_PUBLIC_DATA(AT_surfxml_link___ctn_id) AX_surfxml_link___ctn_id; #define A_surfxml_link___ctn_id (surfxml_bufferstack + AX_surfxml_link___ctn_id) XBT_PUBLIC_DATA(short int) surfxml_link___ctn_id_isset; XBT_PUBLIC_DATA(AT_surfxml_model___prop_value) AX_surfxml_model___prop_value; #define A_surfxml_model___prop_value (surfxml_bufferstack + AX_surfxml_model___prop_value) XBT_PUBLIC_DATA(short int) surfxml_model___prop_value_isset; XBT_PUBLIC_DATA(AT_surfxml_peer_bw___out) AX_surfxml_peer_bw___out; #define A_surfxml_peer_bw___out (surfxml_bufferstack + AX_surfxml_peer_bw___out) XBT_PUBLIC_DATA(short int) surfxml_peer_bw___out_isset; XBT_PUBLIC_DATA(AT_surfxml_bypassASroute_src) AX_surfxml_bypassASroute_src; #define A_surfxml_bypassASroute_src (surfxml_bufferstack + AX_surfxml_bypassASroute_src) XBT_PUBLIC_DATA(short int) surfxml_bypassASroute_src_isset; XBT_PUBLIC_DATA(AT_surfxml_backbone_bandwidth) AX_surfxml_backbone_bandwidth; #define A_surfxml_backbone_bandwidth (surfxml_bufferstack + AX_surfxml_backbone_bandwidth) XBT_PUBLIC_DATA(short int) surfxml_backbone_bandwidth_isset; XBT_PUBLIC_DATA(AT_surfxml_host___link_up) AX_surfxml_host___link_up; #define A_surfxml_host___link_up (surfxml_bufferstack + AX_surfxml_host___link_up) XBT_PUBLIC_DATA(short int) surfxml_host___link_up_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_topology) AX_surfxml_cluster_topology; #define A_surfxml_cluster_topology AX_surfxml_cluster_topology XBT_PUBLIC_DATA(short int) surfxml_cluster_topology_isset; XBT_PUBLIC_DATA(AT_surfxml_ASroute_gw___src) AX_surfxml_ASroute_gw___src; #define A_surfxml_ASroute_gw___src (surfxml_bufferstack + AX_surfxml_ASroute_gw___src) XBT_PUBLIC_DATA(short int) surfxml_ASroute_gw___src_isset; XBT_PUBLIC_DATA(AT_surfxml_random_id) AX_surfxml_random_id; #define A_surfxml_random_id (surfxml_bufferstack + AX_surfxml_random_id) XBT_PUBLIC_DATA(short int) surfxml_random_id_isset; XBT_PUBLIC_DATA(AT_surfxml_peer_power) AX_surfxml_peer_power; #define A_surfxml_peer_power (surfxml_bufferstack + AX_surfxml_peer_power) XBT_PUBLIC_DATA(short int) surfxml_peer_power_isset; XBT_PUBLIC_DATA(AT_surfxml_AS_routing) AX_surfxml_AS_routing; #define A_surfxml_AS_routing AX_surfxml_AS_routing XBT_PUBLIC_DATA(short int) surfxml_AS_routing_isset; XBT_PUBLIC_DATA(AT_surfxml_process_start___time) AX_surfxml_process_start___time; #define A_surfxml_process_start___time (surfxml_bufferstack + AX_surfxml_process_start___time) XBT_PUBLIC_DATA(short int) surfxml_process_start___time_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_topo___parameters) AX_surfxml_cluster_topo___parameters; #define A_surfxml_cluster_topo___parameters (surfxml_bufferstack + AX_surfxml_cluster_topo___parameters) XBT_PUBLIC_DATA(short int) surfxml_cluster_topo___parameters_isset; XBT_PUBLIC_DATA(AT_surfxml_route_dst) AX_surfxml_route_dst; #define A_surfxml_route_dst (surfxml_bufferstack + AX_surfxml_route_dst) XBT_PUBLIC_DATA(short int) surfxml_route_dst_isset; XBT_PUBLIC_DATA(AT_surfxml_host_coordinates) AX_surfxml_host_coordinates; #define A_surfxml_host_coordinates (surfxml_bufferstack + AX_surfxml_host_coordinates) XBT_PUBLIC_DATA(short int) surfxml_host_coordinates_isset; XBT_PUBLIC_DATA(AT_surfxml_host___link_down) AX_surfxml_host___link_down; #define A_surfxml_host___link_down (surfxml_bufferstack + AX_surfxml_host___link_down) XBT_PUBLIC_DATA(short int) surfxml_host___link_down_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_radical) AX_surfxml_cluster_radical; #define A_surfxml_cluster_radical (surfxml_bufferstack + AX_surfxml_cluster_radical) XBT_PUBLIC_DATA(short int) surfxml_cluster_radical_isset; XBT_PUBLIC_DATA(AT_surfxml_config_id) AX_surfxml_config_id; #define A_surfxml_config_id (surfxml_bufferstack + AX_surfxml_config_id) XBT_PUBLIC_DATA(short int) surfxml_config_id_isset; XBT_PUBLIC_DATA(AT_surfxml_cabinet_power) AX_surfxml_cabinet_power; #define A_surfxml_cabinet_power (surfxml_bufferstack + AX_surfxml_cabinet_power) XBT_PUBLIC_DATA(short int) surfxml_cabinet_power_isset; XBT_PUBLIC_DATA(AT_surfxml_model___prop_id) AX_surfxml_model___prop_id; #define A_surfxml_model___prop_id (surfxml_bufferstack + AX_surfxml_model___prop_id) XBT_PUBLIC_DATA(short int) surfxml_model___prop_id_isset; XBT_PUBLIC_DATA(AT_surfxml_peer_coordinates) AX_surfxml_peer_coordinates; #define A_surfxml_peer_coordinates (surfxml_bufferstack + AX_surfxml_peer_coordinates) XBT_PUBLIC_DATA(short int) surfxml_peer_coordinates_isset; XBT_PUBLIC_DATA(AT_surfxml_mstorage_name) AX_surfxml_mstorage_name; #define A_surfxml_mstorage_name (surfxml_bufferstack + AX_surfxml_mstorage_name) XBT_PUBLIC_DATA(short int) surfxml_mstorage_name_isset; XBT_PUBLIC_DATA(AT_surfxml_host___link_id) AX_surfxml_host___link_id; #define A_surfxml_host___link_id (surfxml_bufferstack + AX_surfxml_host___link_id) XBT_PUBLIC_DATA(short int) surfxml_host___link_id_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_loopback___bw) AX_surfxml_cluster_loopback___bw; #define A_surfxml_cluster_loopback___bw (surfxml_bufferstack + AX_surfxml_cluster_loopback___bw) XBT_PUBLIC_DATA(short int) surfxml_cluster_loopback___bw_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_suffix) AX_surfxml_cluster_suffix; #define A_surfxml_cluster_suffix (surfxml_bufferstack + AX_surfxml_cluster_suffix) XBT_PUBLIC_DATA(short int) surfxml_cluster_suffix_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_router___id) AX_surfxml_cluster_router___id; #define A_surfxml_cluster_router___id (surfxml_bufferstack + AX_surfxml_cluster_router___id) XBT_PUBLIC_DATA(short int) surfxml_cluster_router___id_isset; XBT_PUBLIC_DATA(AT_surfxml_prop_id) AX_surfxml_prop_id; #define A_surfxml_prop_id (surfxml_bufferstack + AX_surfxml_prop_id) XBT_PUBLIC_DATA(short int) surfxml_prop_id_isset; XBT_PUBLIC_DATA(AT_surfxml_backbone_id) AX_surfxml_backbone_id; #define A_surfxml_backbone_id (surfxml_bufferstack + AX_surfxml_backbone_id) XBT_PUBLIC_DATA(short int) surfxml_backbone_id_isset; XBT_PUBLIC_DATA(AT_surfxml_link_state___file) AX_surfxml_link_state___file; #define A_surfxml_link_state___file (surfxml_bufferstack + AX_surfxml_link_state___file) XBT_PUBLIC_DATA(short int) surfxml_link_state___file_isset; XBT_PUBLIC_DATA(AT_surfxml_cabinet_lat) AX_surfxml_cabinet_lat; #define A_surfxml_cabinet_lat (surfxml_bufferstack + AX_surfxml_cabinet_lat) XBT_PUBLIC_DATA(short int) surfxml_cabinet_lat_isset; XBT_PUBLIC_DATA(AT_surfxml_storage___type_id) AX_surfxml_storage___type_id; #define A_surfxml_storage___type_id (surfxml_bufferstack + AX_surfxml_storage___type_id) XBT_PUBLIC_DATA(short int) surfxml_storage___type_id_isset; XBT_PUBLIC_DATA(AT_surfxml_storage_content___type) AX_surfxml_storage_content___type; #define A_surfxml_storage_content___type (surfxml_bufferstack + AX_surfxml_storage_content___type) XBT_PUBLIC_DATA(short int) surfxml_storage_content___type_isset; XBT_PUBLIC_DATA(AT_surfxml_random_radical) AX_surfxml_random_radical; #define A_surfxml_random_radical (surfxml_bufferstack + AX_surfxml_random_radical) XBT_PUBLIC_DATA(short int) surfxml_random_radical_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_power) AX_surfxml_cluster_power; #define A_surfxml_cluster_power (surfxml_bufferstack + AX_surfxml_cluster_power) XBT_PUBLIC_DATA(short int) surfxml_cluster_power_isset; XBT_PUBLIC_DATA(AT_surfxml_trace___connect_element) AX_surfxml_trace___connect_element; #define A_surfxml_trace___connect_element (surfxml_bufferstack + AX_surfxml_trace___connect_element) XBT_PUBLIC_DATA(short int) surfxml_trace___connect_element_isset; XBT_PUBLIC_DATA(AT_surfxml_link_latency) AX_surfxml_link_latency; #define A_surfxml_link_latency (surfxml_bufferstack + AX_surfxml_link_latency) XBT_PUBLIC_DATA(short int) surfxml_link_latency_isset; XBT_PUBLIC_DATA(AT_surfxml_host_state) AX_surfxml_host_state; #define A_surfxml_host_state AX_surfxml_host_state XBT_PUBLIC_DATA(short int) surfxml_host_state_isset; XBT_PUBLIC_DATA(AT_surfxml_host_core) AX_surfxml_host_core; #define A_surfxml_host_core (surfxml_bufferstack + AX_surfxml_host_core) XBT_PUBLIC_DATA(short int) surfxml_host_core_isset; XBT_PUBLIC_DATA(AT_surfxml_storage___type_size) AX_surfxml_storage___type_size; #define A_surfxml_storage___type_size (surfxml_bufferstack + AX_surfxml_storage___type_size) XBT_PUBLIC_DATA(short int) surfxml_storage___type_size_isset; XBT_PUBLIC_DATA(AT_surfxml_mount_name) AX_surfxml_mount_name; #define A_surfxml_mount_name (surfxml_bufferstack + AX_surfxml_mount_name) XBT_PUBLIC_DATA(short int) surfxml_mount_name_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_id) AX_surfxml_cluster_id; #define A_surfxml_cluster_id (surfxml_bufferstack + AX_surfxml_cluster_id) XBT_PUBLIC_DATA(short int) surfxml_cluster_id_isset; XBT_PUBLIC_DATA(AT_surfxml_peer_state___file) AX_surfxml_peer_state___file; #define A_surfxml_peer_state___file (surfxml_bufferstack + AX_surfxml_peer_state___file) XBT_PUBLIC_DATA(short int) surfxml_peer_state___file_isset; XBT_PUBLIC_DATA(AT_surfxml_host_state___file) AX_surfxml_host_state___file; #define A_surfxml_host_state___file (surfxml_bufferstack + AX_surfxml_host_state___file) XBT_PUBLIC_DATA(short int) surfxml_host_state___file_isset; XBT_PUBLIC_DATA(AT_surfxml_bypassASroute_dst) AX_surfxml_bypassASroute_dst; #define A_surfxml_bypassASroute_dst (surfxml_bufferstack + AX_surfxml_bypassASroute_dst) XBT_PUBLIC_DATA(short int) surfxml_bypassASroute_dst_isset; XBT_PUBLIC_DATA(AT_surfxml_link_state) AX_surfxml_link_state; #define A_surfxml_link_state AX_surfxml_link_state XBT_PUBLIC_DATA(short int) surfxml_link_state_isset; XBT_PUBLIC_DATA(AT_surfxml_bypassASroute_gw___dst) AX_surfxml_bypassASroute_gw___dst; #define A_surfxml_bypassASroute_gw___dst (surfxml_bufferstack + AX_surfxml_bypassASroute_gw___dst) XBT_PUBLIC_DATA(short int) surfxml_bypassASroute_gw___dst_isset; XBT_PUBLIC_DATA(AT_surfxml_random_std___deviation) AX_surfxml_random_std___deviation; #define A_surfxml_random_std___deviation (surfxml_bufferstack + AX_surfxml_random_std___deviation) XBT_PUBLIC_DATA(short int) surfxml_random_std___deviation_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_bb___bw) AX_surfxml_cluster_bb___bw; #define A_surfxml_cluster_bb___bw (surfxml_bufferstack + AX_surfxml_cluster_bb___bw) XBT_PUBLIC_DATA(short int) surfxml_cluster_bb___bw_isset; XBT_PUBLIC_DATA(AT_surfxml_trace___connect_trace) AX_surfxml_trace___connect_trace; #define A_surfxml_trace___connect_trace (surfxml_bufferstack + AX_surfxml_trace___connect_trace) XBT_PUBLIC_DATA(short int) surfxml_trace___connect_trace_isset; XBT_PUBLIC_DATA(AT_surfxml_peer_lat) AX_surfxml_peer_lat; #define A_surfxml_peer_lat (surfxml_bufferstack + AX_surfxml_peer_lat) XBT_PUBLIC_DATA(short int) surfxml_peer_lat_isset; XBT_PUBLIC_DATA(AT_surfxml_cabinet_bw) AX_surfxml_cabinet_bw; #define A_surfxml_cabinet_bw (surfxml_bufferstack + AX_surfxml_cabinet_bw) XBT_PUBLIC_DATA(short int) surfxml_cabinet_bw_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_prefix) AX_surfxml_cluster_prefix; #define A_surfxml_cluster_prefix (surfxml_bufferstack + AX_surfxml_cluster_prefix) XBT_PUBLIC_DATA(short int) surfxml_cluster_prefix_isset; XBT_PUBLIC_DATA(AT_surfxml_storage_attach) AX_surfxml_storage_attach; #define A_surfxml_storage_attach (surfxml_bufferstack + AX_surfxml_storage_attach) XBT_PUBLIC_DATA(short int) surfxml_storage_attach_isset; XBT_PUBLIC_DATA(AT_surfxml_random_min) AX_surfxml_random_min; #define A_surfxml_random_min (surfxml_bufferstack + AX_surfxml_random_min) XBT_PUBLIC_DATA(short int) surfxml_random_min_isset; XBT_PUBLIC_DATA(AT_surfxml_trace___connect_kind) AX_surfxml_trace___connect_kind; #define A_surfxml_trace___connect_kind AX_surfxml_trace___connect_kind XBT_PUBLIC_DATA(short int) surfxml_trace___connect_kind_isset; XBT_PUBLIC_DATA(AT_surfxml_router_coordinates) AX_surfxml_router_coordinates; #define A_surfxml_router_coordinates (surfxml_bufferstack + AX_surfxml_router_coordinates) XBT_PUBLIC_DATA(short int) surfxml_router_coordinates_isset; XBT_PUBLIC_DATA(AT_surfxml_bypassASroute_gw___src) AX_surfxml_bypassASroute_gw___src; #define A_surfxml_bypassASroute_gw___src (surfxml_bufferstack + AX_surfxml_bypassASroute_gw___src) XBT_PUBLIC_DATA(short int) surfxml_bypassASroute_gw___src_isset; XBT_PUBLIC_DATA(AT_surfxml_backbone_latency) AX_surfxml_backbone_latency; #define A_surfxml_backbone_latency (surfxml_bufferstack + AX_surfxml_backbone_latency) XBT_PUBLIC_DATA(short int) surfxml_backbone_latency_isset; XBT_PUBLIC_DATA(AT_surfxml_host_id) AX_surfxml_host_id; #define A_surfxml_host_id (surfxml_bufferstack + AX_surfxml_host_id) XBT_PUBLIC_DATA(short int) surfxml_host_id_isset; XBT_PUBLIC_DATA(AT_surfxml_AS_id) AX_surfxml_AS_id; #define A_surfxml_AS_id (surfxml_bufferstack + AX_surfxml_AS_id) XBT_PUBLIC_DATA(short int) surfxml_AS_id_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_state___file) AX_surfxml_cluster_state___file; #define A_surfxml_cluster_state___file (surfxml_bufferstack + AX_surfxml_cluster_state___file) XBT_PUBLIC_DATA(short int) surfxml_cluster_state___file_isset; XBT_PUBLIC_DATA(AT_surfxml_peer_bw___in) AX_surfxml_peer_bw___in; #define A_surfxml_peer_bw___in (surfxml_bufferstack + AX_surfxml_peer_bw___in) XBT_PUBLIC_DATA(short int) surfxml_peer_bw___in_isset; XBT_PUBLIC_DATA(AT_surfxml_ASroute_dst) AX_surfxml_ASroute_dst; #define A_surfxml_ASroute_dst (surfxml_bufferstack + AX_surfxml_ASroute_dst) XBT_PUBLIC_DATA(short int) surfxml_ASroute_dst_isset; XBT_PUBLIC_DATA(AT_surfxml_trace_file) AX_surfxml_trace_file; #define A_surfxml_trace_file (surfxml_bufferstack + AX_surfxml_trace_file) XBT_PUBLIC_DATA(short int) surfxml_trace_file_isset; XBT_PUBLIC_DATA(AT_surfxml_router_id) AX_surfxml_router_id; #define A_surfxml_router_id (surfxml_bufferstack + AX_surfxml_router_id) XBT_PUBLIC_DATA(short int) surfxml_router_id_isset; XBT_PUBLIC_DATA(AT_surfxml_prop_value) AX_surfxml_prop_value; #define A_surfxml_prop_value (surfxml_bufferstack + AX_surfxml_prop_value) XBT_PUBLIC_DATA(short int) surfxml_prop_value_isset; XBT_PUBLIC_DATA(AT_surfxml_storage_id) AX_surfxml_storage_id; #define A_surfxml_storage_id (surfxml_bufferstack + AX_surfxml_storage_id) XBT_PUBLIC_DATA(short int) surfxml_storage_id_isset; XBT_PUBLIC_DATA(AT_surfxml_storage_content) AX_surfxml_storage_content; #define A_surfxml_storage_content (surfxml_bufferstack + AX_surfxml_storage_content) XBT_PUBLIC_DATA(short int) surfxml_storage_content_isset; XBT_PUBLIC_DATA(AT_surfxml_link_sharing___policy) AX_surfxml_link_sharing___policy; #define A_surfxml_link_sharing___policy AX_surfxml_link_sharing___policy XBT_PUBLIC_DATA(short int) surfxml_link_sharing___policy_isset; XBT_PUBLIC_DATA(AT_surfxml_process_on___failure) AX_surfxml_process_on___failure; #define A_surfxml_process_on___failure AX_surfxml_process_on___failure XBT_PUBLIC_DATA(short int) surfxml_process_on___failure_isset; XBT_PUBLIC_DATA(AT_surfxml_host_power) AX_surfxml_host_power; #define A_surfxml_host_power (surfxml_bufferstack + AX_surfxml_host_power) XBT_PUBLIC_DATA(short int) surfxml_host_power_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_availability___file) AX_surfxml_cluster_availability___file; #define A_surfxml_cluster_availability___file (surfxml_bufferstack + AX_surfxml_cluster_availability___file) XBT_PUBLIC_DATA(short int) surfxml_cluster_availability___file_isset; XBT_PUBLIC_DATA(AT_surfxml_platform_version) AX_surfxml_platform_version; #define A_surfxml_platform_version (surfxml_bufferstack + AX_surfxml_platform_version) XBT_PUBLIC_DATA(short int) surfxml_platform_version_isset; XBT_PUBLIC_DATA(AT_surfxml_host_availability) AX_surfxml_host_availability; #define A_surfxml_host_availability (surfxml_bufferstack + AX_surfxml_host_availability) XBT_PUBLIC_DATA(short int) surfxml_host_availability_isset; XBT_PUBLIC_DATA(AT_surfxml_mount_storageId) AX_surfxml_mount_storageId; #define A_surfxml_mount_storageId (surfxml_bufferstack + AX_surfxml_mount_storageId) XBT_PUBLIC_DATA(short int) surfxml_mount_storageId_isset; XBT_PUBLIC_DATA(AT_surfxml_host_pstate) AX_surfxml_host_pstate; #define A_surfxml_host_pstate (surfxml_bufferstack + AX_surfxml_host_pstate) XBT_PUBLIC_DATA(short int) surfxml_host_pstate_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_bw) AX_surfxml_cluster_bw; #define A_surfxml_cluster_bw (surfxml_bufferstack + AX_surfxml_cluster_bw) XBT_PUBLIC_DATA(short int) surfxml_cluster_bw_isset; XBT_PUBLIC_DATA(AT_surfxml_argument_value) AX_surfxml_argument_value; #define A_surfxml_argument_value (surfxml_bufferstack + AX_surfxml_argument_value) XBT_PUBLIC_DATA(short int) surfxml_argument_value_isset; XBT_PUBLIC_DATA(AT_surfxml_route_symmetrical) AX_surfxml_route_symmetrical; #define A_surfxml_route_symmetrical AX_surfxml_route_symmetrical XBT_PUBLIC_DATA(short int) surfxml_route_symmetrical_isset; XBT_PUBLIC_DATA(AT_surfxml_route_src) AX_surfxml_route_src; #define A_surfxml_route_src (surfxml_bufferstack + AX_surfxml_route_src) XBT_PUBLIC_DATA(short int) surfxml_route_src_isset; XBT_PUBLIC_DATA(AT_surfxml_peer_availability___file) AX_surfxml_peer_availability___file; #define A_surfxml_peer_availability___file (surfxml_bufferstack + AX_surfxml_peer_availability___file) XBT_PUBLIC_DATA(short int) surfxml_peer_availability___file_isset; XBT_PUBLIC_DATA(AT_surfxml_ASroute_symmetrical) AX_surfxml_ASroute_symmetrical; #define A_surfxml_ASroute_symmetrical AX_surfxml_ASroute_symmetrical XBT_PUBLIC_DATA(short int) surfxml_ASroute_symmetrical_isset; XBT_PUBLIC_DATA(AT_surfxml_cluster_sharing___policy) AX_surfxml_cluster_sharing___policy; #define A_surfxml_cluster_sharing___policy AX_surfxml_cluster_sharing___policy XBT_PUBLIC_DATA(short int) surfxml_cluster_sharing___policy_isset; XBT_PUBLIC_DATA(AT_surfxml_gpu_name) AX_surfxml_gpu_name; #define A_surfxml_gpu_name (surfxml_bufferstack + AX_surfxml_gpu_name) XBT_PUBLIC_DATA(short int) surfxml_gpu_name_isset; XBT_PUBLIC_DATA(AT_surfxml_storage___type_model) AX_surfxml_storage___type_model; #define A_surfxml_storage___type_model (surfxml_bufferstack + AX_surfxml_storage___type_model) XBT_PUBLIC_DATA(short int) surfxml_storage___type_model_isset; /* XML application utilities. */ XBT_PUBLIC(int) surfxml_element_context(int); /* XML processor entry point. */ XBT_PUBLIC(int) yylex(void); /* Flexml error handling function (useful only when -q flag passed to flexml) */ const char * surfxml_parse_err_msg(void); #endif SimGrid-3.11/include/surf/surf_routing.h000644 001750 001750 00000004012 12342443646 017332 0ustar00cici000000 000000 /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _SURF_SURF_ROUTING_H #define _SURF_SURF_ROUTING_H #include "xbt/lib.h" #include "simgrid/platf.h" SG_BEGIN_DECL() XBT_PUBLIC(xbt_lib_t) host_lib; XBT_PUBLIC(int) ROUTING_HOST_LEVEL; //Routing level XBT_PUBLIC(int) SURF_CPU_LEVEL; //Surf cpu level XBT_PUBLIC(int) SURF_WKS_LEVEL; //Surf workstation level XBT_PUBLIC(int) SIMIX_HOST_LEVEL; //Simix host level XBT_PUBLIC(int) SIMIX_STORAGE_LEVEL; //Simix storage level XBT_PUBLIC(int) MSG_HOST_LEVEL; //Msg level XBT_PUBLIC(int) SD_HOST_LEVEL; //Simdag host level XBT_PUBLIC(int) SD_STORAGE_LEVEL; //Simdag storage level XBT_PUBLIC(int) COORD_HOST_LEVEL; //Coordinates level XBT_PUBLIC(int) NS3_HOST_LEVEL; //host node for ns3 XBT_PUBLIC(xbt_lib_t) link_lib; XBT_PUBLIC(int) SD_LINK_LEVEL; //Simdag level XBT_PUBLIC(int) SURF_LINK_LEVEL; //Surf level XBT_PUBLIC(int) NS3_LINK_LEVEL; //link for ns3 XBT_PUBLIC(xbt_lib_t) as_router_lib; XBT_PUBLIC(int) ROUTING_ASR_LEVEL; //Routing level XBT_PUBLIC(int) COORD_ASR_LEVEL; //Coordinates level XBT_PUBLIC(int) NS3_ASR_LEVEL; //host node for ns3 XBT_PUBLIC(int) ROUTING_PROP_ASR_LEVEL; //Properties for AS and router XBT_PUBLIC(xbt_lib_t) storage_lib; XBT_PUBLIC(int) ROUTING_STORAGE_LEVEL; //Routing storage level XBT_PUBLIC(int) ROUTING_STORAGE_HOST_LEVEL; XBT_PUBLIC(int) SURF_STORAGE_LEVEL; // Surf storage level XBT_PUBLIC(xbt_lib_t) file_lib; XBT_PUBLIC(xbt_lib_t) storage_type_lib; XBT_PUBLIC(int) ROUTING_STORAGE_TYPE_LEVEL; //Routing storage_type level /* The callbacks to register for the routing to work */ void routing_AS_begin(sg_platf_AS_cbarg_t AS); void routing_AS_end(sg_platf_AS_cbarg_t AS); void routing_cluster_add_backbone(void* bb); SG_END_DECL() #endif /* _SURF_SURF_H */ SimGrid-3.11/include/simgrid.h000644 001750 001750 00000001266 12342443646 015273 0ustar00cici000000 000000 /* simgrid.h - Public interface all SimGrid APIs */ /* Copyright (c) 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef SIMGRID_H #define SIMGRID_H #include #include #include #include #include #include #include // SG_BEGIN_DECL() // nothing // SG_END_DECL() #endif /* SG_PLATF_H */ SimGrid-3.11/.gitversion000644 001750 001750 00000000010 12342443670 014212 0ustar00cici000000 000000 875f018 SimGrid-3.11/NEWS000644 001750 001750 00000032035 12342443666 012540 0ustar00cici000000 000000 _ _____ _ _ __ _____ _ __ ___(_) ___ _ __ |___ / / / | \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ | | | \ V / __/ | \__ \ | (_) | | | | ___) || | | \_/ \___|_| |___/_|\___/|_| |_| |____(_)_|_| May 31 2014 The Class Release. Major changes: * Surf is now in C++ (and documented!) * Virtual Machine model for Cloud Simulation * Surf callbacks: plug your code directly in Surf! * Simcalls are script-generated to clean the mess _ _____ _ ___ __ _____ _ __ ___(_) ___ _ __ |___ / / |/ _ \ \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ | | | | | \ V / __/ | \__ \ | (_) | | | | ___) || | |_| | \_/ \___|_| |___/_|\___/|_| |_| |____(_)_|\___/ Nov 17 2013 The Clean Diaper Release, a.k.a. SimGrid is leak-free. Major changes: * Preliminary DVFS support to track the energy consumption * Java is back in the main package (and is very stable). * The storage sub-modules is now believed to be usable. * SMPI is now very stable (we pass most MPICH tests). * Lots of memory leaks were corrected in this release. * Verification and model checking further improved: liveness+SMPI works; reduction through state equality detection Plus the usual load of bug fixes and small improvements _ _____ ___ __ _____ _ __ ___(_) ___ _ __ |___ // _ \ \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ (_) | \ V / __/ | \__ \ | (_) | | | | ___) \__, | \_/ \___|_| |___/_|\___/|_| |_| |____(_)/_/ Feb 5 2013 The "Grasgory" release. Major changes: * Gras was completely removed from this version. * Documentation reorganization to ease browsing it. * New default value for the TCP_gamma parameter: 4MiB _ _____ ___ _ __ _____ _ __ ___(_) ___ _ __ |___ / ( _ ) / | \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ / _ \ | | \ V / __/ | \__ \ | (_) | | | | ___) | (_) || | \_/ \___|_| |___/_|\___/|_| |_| |____(_)___(_)_| Oct 27 2012 The "we are told that some people want to also *install* the simgrid framework" release. * Add missing manpage to the archive. _ _____ ___ __ _____ _ __ ___(_) ___ _ __ |___ / ( _ ) \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ / _ \ \ V / __/ | \__ \ | (_) | | | | ___) | (_) | \_/ \___|_| |___/_|\___/|_| |_| |____(_)___/ Oct 25 2012 The Psssshiiiit release: SimGrid jumps into the Cloud. Major changes: * Experimental interface to manipulate VMs, EC2-style. * Fixes around process restart and stochastic workloads * platf: New C interface to create fixed or random platforms * SimDag: Many fixes and improvements of typed tasks * SMPI now covers more of the MPI interface. More datatypes, more functions, more robust. * Model-checking: mmalloc is more robust to user errors. _ _____ _____ _ __ _____ _ __ ___(_) ___ _ __ |___ /|___ / | \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ / /| | \ V / __/ | \__ \ | (_) | | | | ___) | / /_| | \_/ \___|_| |___/_|\___/|_| |_| |____(_)_/(_)_| June 7 2012 The "cleaning the cleanup" release. Major changes: * Portability fixups for Mac OSX and Windows * Some other bug fixing and various polishing. _ ____ _____ __ _____ _ __ ___(_) ___ _ __ |___ /|___ | \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ / / \ V / __/ | \__ \ | (_) | | | | ___) | / / \_/ \___|_| |___/_|\___/|_| |_| |____(_)_/ May 15 2012 The "spring cleanups (before the next Big Project kicks in)" release. Major changes: * Major cleanups all around (doc, user options, MSG, Lua, internals) Small backward compatibility glitches may have been introduced * Parallel execution of user code should be stable and efficient now * SMPI is now considered stable * Add temporals to Model-Checking (highly experimental right now) _ _____ __ ____ __ _____ _ __ ___(_) ___ _ __ |___ / / /_ |___ \ \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \| '_ \ __) | \ V / __/ | \__ \ | (_) | | | | ___) | (_) | / __/ \_/ \___|_| |___/_|\___/|_| |_| |____(_)___(_)_____| Oct 5 2011 The "Not coding new stuff allows to polish old things" release. * Portability to Mac and Windows improved. * Possible misconfigurations (contexts, libPCRE) made impossible by removing the option or providing sane default value. * Experimental support to NS3 simulator as a back-end. _ _____ __ _ __ _____ _ __ ___(_) ___ _ __ |___ / / /_ / | \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \| '_ \ | | \ V / __/ | \__ \ | (_) | | | | ___) | (_) || | \_/ \___|_| |___/_|\___/|_| |_| |____(_)___(_)_| Jun 27 2011 The "Oops, we broke Macs too" release. Bug fix to an issue preventing SimGrid from working on Mac OSX. _ _____ __ __ _____ _ __ ___(_) ___ _ __ |___ / / /_ \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \| '_ \ \ V / __/ | \__ \ | (_) | | | | ___) | (_) | \_/ \___|_| |___/_|\___/|_| |_| |____(_)___/ Jun 21 2011 The "OMG! They Killed Kenny!" version. Major changes: * Java and Ruby bindings were removed from the main archive - They are now distributed separately * GRAS is not considered as stable anymore, but experimental. Sorry. * First support for parallel simulation: - Can run the user code of any simulation in parallel. - Basic support for multi-cores hosts in platform files * Improved P2P support: - Peer tag in platform files for DSL connected nodes - Vivaldi routing scheme for lightweigted yet accurate models * Improved SMPI: Faster Fortran, automatic privatization of C globals * Tracing: trace contains the full platform hierarchy exactly as declared using the ASes of the platform file Plus numerous other goodies (check the ChangeLog for details) _ _____ ____ __ _____ _ __ ___(_) ___ _ __ |___ / | ___| \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ |___ \ \ V / __/ | \__ \ | (_) | | | | ___) | ___) | \_/ \___|_| |___/_|\___/|_| |_| |____(_)____/ 01 Dec 2010 The "Winter in Frejus" release. Also known as "ANR/ADT funding helps" Major changes are: * New feature: Model check any simgrid simulation * SMPI is now very usable. * Visualization: - now covers the whole framework - major usability improvements * SURF: - scalable platform management through hierarchical description - new efficient way to bypass the XML parser * MSG: at last asynchronous functions are available * SIMDAG: many usability improvements (dotloader, ...) * GRAS: finally catch up with latest internal evolutions * Build chain: - Windows port: should be usable now but still considered experimental - Autotools have now been completely removed _ _____ _ _ _ __ _____ _ __ ___(_) ___ _ __ |___ /| || | / | \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \| || |_ | | \ V / __/ | \__ \ | (_) | | | | ___) |__ _|| | \_/ \___|_| |___/_|\___/|_| |_| |____(_) |_|(_)_| 04 May 2010 The "Polishing easter eggs is probably a good idea" release. This is a bug fixes release only. _ _____ _ _ __ _____ _ __ ___(_) ___ _ __ |___ /| || | \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \| || |_ \ V / __/ | \__ \ | (_) | | | | ___) |__ _| \_/ \___|_| |___/_|\___/|_| |_| |____(_) |_| 28 Apr 2010 The "Easter in Cargese" release. Also known as (major changes): * the "se habla Java, Ruby 話せます, fala-se Lua (and deaf-friendly)" ~> bindings were greatly improved ~> new tracing infrastructure for better visualization introduced * the "Welcome to configury modernity" release. ~> we switched from autotools to cmake, and improved our cdash _ _____ _____ _ _ __ _____ _ __ ___(_) ___ _ __ |___ / |___ /| || | \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ |_ \| || |_ \ V / __/ | \__ \ | (_) | | | | ___) | ___) |__ _| \_/ \___|_| |___/_|\___/|_| |_| |____(_)____(_) |_| 24 Dec 2009 The "Desktop Grid needs love too" release (also called "Xmas release"). Most important changes: * Big speedup through lazy evaluation of the linear models * Supernovae mode: Compile everything in one unit to improve inlining * Simix network module for internal cleanups * Load DAX of applications into SimDag * Lot of small cleanups and other bug fixes _ _____ _____ _____ __ _____ _ __ ___(_) ___ _ __ |___ / |___ / |___ / \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ |_ \ |_ \ \ V / __/ | \__ \ | (_) | | | | ___) | ___) | ___) | \_/ \___|_| |___/_|\___/|_| |_| |____(_)____(_)____/ 20 Aug 2009 The "Need for Speed" release. Big speedup through some function inlining. _ _____ _____ ____ __ _____ _ __ ___(_) ___ _ __ |___ / |___ / |___ \ \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ |_ \ __) | \ V / __/ | \__ \ | (_) | | | | ___) | ___) | / __/ \_/ \___|_| |___/_|\___/|_| |_| |____(_)____(_)_____| 19 Aug 2009 The "Simplicity does not preceed complexity, but follows it" release. Most important changes: * surf and simix modules reworked for simplification. It lays the ground for future extensions and improvements of SimGrid * SMPI was further improved, although not ready for production use yet. On the way, we gained a bit more than 5% on the classical master/slave example. More to come on this in future releases. _ _____ _____ _ __ _____ _ __ ___(_) ___ _ __ |___ / |___ / / | \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ |_ \ | | \ V / __/ | \__ \ | (_) | | | | ___) | ___) || | \_/ \___|_| |___/_|\___/|_| |_| |____(_)____(_)_| 27 Jun 2009 This dot release is mainly a maintenance one. Most important changes: * We fixed a large amount of bugs all around * We sanitized the way configuration is handled internally. Try passing --cfg-help to binaries compiled against this version. * SMPI is in better shape: lot of bugs fixing & usability improvements It may be worth trying it (even if all bugs are not gone yet) This version may have a bit more of memleaks than 3.3. This will be fixed in a latter release. ____ _ ____ _ _ / ___|(_)_ __ ___ / ___|_ __(_) __| | \___ \| | '_ ` _ \| | _| '__| |/ _` | ___) | | | | | | | |_| | | | | (_| | |____/|_|_| |_| |_|\____|_| |_|\__,_| _ _____ _____ __ _____ _ __ ___(_) ___ _ __ |___ / |___ / \ \ / / _ \ '__/ __| |/ _ \| '_ \ |_ \ |_ \ \ V / __/ | \__ \ | (_) | | | | ___) | ___) | \_/ \___|_| |___/_|\___/|_| |_| |____(_)____/ _ _ _ _ _ _ _ | |___ __ _ __| |_ ___ __| | | || | ' \| / -_) _` (_-< ' \/ -_) _` | \_,_|_||_|_\___\__,_/__/_||_\___\__,_| Mar 16 2007 homepage: http://simgrid.gforge.inria.fr/ download: http://gforge.inria.fr/frs/?group_id=12 At least, after 2 years of hard work, we managed to release the 3.3 version of the SimGrid framework. There is so many changes that the changelog only lists the most important ones, leaving alone the small improvements, bug fixing and new gadgets. In short: * Java bindings * New simulation models, and improvement of the GTNetS wrapper * Large memory savings (mainly in parser) * Faster (twice faster is not uncommon, and from 20 hours to 2 minutes on very large scenarios) * Much better scalability (tested up to 250,000 processes) * Complete regression testing framework so that you can trust the tool * Lot of neat new modules in the XBT toolbox This version was thoroughly tested on linux 32bits and 64bits (debian), as well as Mac OSX (leopard). Unfortunately, our windows-guy left, and we cannot release the windows version at the same time than the other archs. Any help would be really welcomed here. Some of the 96 included test suites are known to fail, but everything should work anyway (don't panic): * The amok module does not work in real deployment ATM, but I don't see this as release critical since I'm not aware of anyone needing this right now * Some tests about the ability of GRAS to receive messages from exotic platforms fail because I've lost access to these platforms (such as AIX) * the example/gras/pmm sometimes fails (about 1/10 of cases). I'm quite puzzled, but I suspect a bug in the test, not in the lib. * the tesh auto-tests "fail" on Mac OSX. This is because "rm -rf" is sometimes too verbose (when the OS creates hidden files, I suspect), but tesh definitely work as the rest on this arch. We hope to manage to do more timely releases in the future, even if that may turn out difficult since big stuff is coming (I don't say much here for the suspense ;) We hope you'll enjoy this new version, and please report any feedback on the list. Martin Quinson (for Da SimGrid Team) SimGrid-3.11/INSTALL000644 001750 001750 00000003765 12342443666 013102 0ustar00cici000000 000000 ************************************************ * Installation information specific to SimGrid * ************************************************ The main source of information on how to compile SimGrid is the project documentation available in doc/install.html or online on our website http://simgrid.gforge.inria.fr/ . This INSTALL file contains mainly generic information on how to compile SimGrid or any project using cmake. Quick way to compile ==================== In short, the way to compile SimGrid depends on whether you are compiling a tar.gz archive or directly from the Git. (1) configure SimGrid (both in Git and archives) $ cmake ./ Main options are: -DCMAKE_INSTALL_PREFIX=: specify where to install SimGrid -Denable_maintainer_mode=on/off: get the maintainer files regenerated automatically -Denable_compile_optimizations=on/off: compile or not with optimizations -Denable_java=on/off: enable or not the Java bindings -Denable_scala=on/off: enable or not the Scala bindings -Denable_lua=on/off: enable or not the lua bindings -Denable_smpi=on/off: enable or not smpi -Denable_model-checking=on/off: enable or not the model-checker See below for other configure options which are common to any project, not only SimGrid related. (2) Compile it $ make (3) Test it (optional) $ make check $ ctest (4) Install it $ make install Dependencies ============ SimGrid archives do not have any firm dependencies. If you want to compile, you must have installed perl and cmake version 2.6 or above. If you want to compile the java bindings, you have to have a java compiler, and the jni.h header file (available from the JDK). If you want to compile the lua bindings, you have to have lua5.1 executable and liblua5.1-dev. If you want to compile smpi, you should install f2c to use Fortran code. If you want to compile the GTNetS backend, you have to have a patched version of GTNetS installed. The patch lives in the contrib section of the Git. SimGrid-3.11/teshsuite/000755 001750 001750 00000000000 12342443654 014050 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/000755 001750 001750 00000000000 12342443654 014636 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/storage/000755 001750 001750 00000000000 12342443670 016300 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/storage/deployment.xml000644 001750 001750 00000000334 12342443670 021202 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/storage/storage_basic.c000644 001750 001750 00000016004 12342443665 021256 0ustar00cici000000 000000 /* Copyright (c) 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "msg/msg.h" #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_CATEGORY(storage,"Messages specific for this simulation"); void storage_info(msg_host_t host); void display_storage_properties(msg_storage_t storage); int hsm_put(const char *remote_host, const char *src, const char *dest); sg_size_t write_local_file(const char *dest, sg_size_t file_size); sg_size_t read_local_file(const char *src); void dump_storage_by_name(char *name); void display_storage_content(msg_storage_t storage); void get_set_storage_data(const char *storage_name); void dump_platform_storages(void); int client(int argc, char *argv[]); int server(int argc, char *argv[]); void storage_info(msg_host_t host) { const char* host_name = MSG_host_get_name(host); XBT_INFO("*** Storage info on %s ***", host_name); xbt_dict_cursor_t cursor = NULL; char* mount_name; char* storage_name; msg_storage_t storage; xbt_dict_t storage_list = MSG_host_get_mounted_storage_list(MSG_host_self()); xbt_dict_foreach(storage_list,cursor,mount_name,storage_name) { XBT_INFO("\tStorage name: %s, mount name: %s", storage_name, mount_name); storage = MSG_storage_get_by_name(storage_name); sg_size_t free_size = MSG_storage_get_free_size(storage); sg_size_t used_size = MSG_storage_get_used_size(storage); XBT_INFO("\t\tFree size: %llu bytes", free_size); XBT_INFO("\t\tUsed size: %llu bytes", used_size); display_storage_properties(storage); dump_storage_by_name(storage_name); } xbt_dict_free(&storage_list); } void display_storage_properties(msg_storage_t storage){ xbt_dict_cursor_t cursor = NULL; char *key, *data; xbt_dict_t props = MSG_storage_get_properties(storage); if (xbt_dict_length(props) > 0){ XBT_INFO("\tProperties of mounted storage: %s", MSG_storage_get_name(storage)); xbt_dict_foreach(props, cursor, key, data) XBT_INFO("\t\t'%s' -> '%s'", key, data); }else{ XBT_INFO("\tNo property attached."); } } // Read src file on local disk and send a put message to remote host (size of message = size of src file) int hsm_put(const char *remote_host, const char *src, const char *dest){ // Read local src file, and return the size that was actually read sg_size_t read_size = read_local_file(src); // Send file XBT_INFO("%s sends %llu to %s",MSG_host_get_name(MSG_host_self()),read_size,remote_host); msg_task_t to_execute = MSG_task_create((const char*)"hsm_put", 0, (double) read_size, (void*)dest); MSG_task_send(to_execute, remote_host); MSG_process_sleep(.4); return 1; } sg_size_t write_local_file(const char *dest, sg_size_t file_size) { sg_size_t written; msg_file_t file = MSG_file_open(dest, NULL); written = MSG_file_write(file, file_size); XBT_INFO("%llu bytes on %llu bytes have been written by %s on /sd1",written, file_size, MSG_host_get_name(MSG_host_self())); MSG_file_close(file); return written; } sg_size_t read_local_file(const char *src) { sg_size_t read, file_size; msg_file_t file = MSG_file_open(src, NULL); file_size = MSG_file_get_size(file); read = MSG_file_read(file, file_size); XBT_INFO("%s has read %llu on %s",MSG_host_get_name(MSG_host_self()),read,src); MSG_file_close(file); return read; } void dump_storage_by_name(char *name){ XBT_INFO("*** Dump a storage element ***"); msg_storage_t storage = MSG_storage_get_by_name(name); if(storage){ display_storage_content(storage); } else{ XBT_INFO("Unable to retrieve storage element by its name: %s.", name); } } void display_storage_content(msg_storage_t storage){ XBT_INFO("Print the content of the storage element: %s",MSG_storage_get_name(storage)); xbt_dict_cursor_t cursor = NULL; char *file; sg_size_t *psize; xbt_dict_t content = MSG_storage_get_content(storage); if (content){ xbt_dict_foreach(content, cursor, file, psize) XBT_INFO("\t%s size: %llu bytes", file, *psize); } else { XBT_INFO("\tNo content."); } xbt_dict_free(&content); } void get_set_storage_data(const char *storage_name){ XBT_INFO("*** GET/SET DATA for storage element: %s ***",storage_name); msg_storage_t storage = MSG_storage_get_by_name(storage_name); char *data = MSG_storage_get_data(storage); XBT_INFO("Get data: '%s'", data); MSG_storage_set_data(storage, xbt_strdup("Some data")); data = MSG_storage_get_data(storage); XBT_INFO("\tSet and get data: '%s'", data); xbt_free(data); } void dump_platform_storages(void){ unsigned int cursor; xbt_dynar_t storages = MSG_storages_as_dynar(); msg_storage_t storage; xbt_dynar_foreach(storages, cursor, storage){ XBT_INFO("Storage %s is attached to %s", MSG_storage_get_name(storage), MSG_storage_get_host(storage)); MSG_storage_set_property_value(storage, "other usage", xbt_strdup("gpfs"), xbt_free); } xbt_dynar_free(&storages); } int client(int argc, char *argv[]) { hsm_put("server","/sd1/doc/simgrid/examples/cxx/autoDestination/FinalizeTask.cxx","/sd2/scratch/toto.cxx"); hsm_put("server","/sd1/doc/simgrid/examples/cxx/autoDestination/autoDestination_deployment.xml","/sd2/scratch/titi.xml"); hsm_put("server","/sd1/doc/simgrid/examples/cxx/autoDestination/Slave.cxx","/sd2/scratch/tata.cxx"); msg_task_t finalize = MSG_task_create("finalize", 0, 0, NULL); MSG_task_send(finalize, "server"); get_set_storage_data("cdisk"); return 1; } int server(int argc, char *argv[]) { msg_task_t to_execute = NULL; _XBT_GNUC_UNUSED int res; storage_info(MSG_host_self()); XBT_INFO("Server waiting for transfers ..."); while(1){ res = MSG_task_receive(&(to_execute), MSG_host_get_name(MSG_host_self())); xbt_assert(res == MSG_OK, "MSG_task_get failed"); const char *task_name; task_name = MSG_task_get_name(to_execute); if (!strcmp(task_name, "finalize")) { // Shutdown ... MSG_task_destroy(to_execute); break; } else if(!strcmp(task_name,"hsm_put")){// Receive file to save // Write file on local disk char *dest = MSG_task_get_data(to_execute); sg_size_t size_to_write = (sg_size_t)MSG_task_get_data_size(to_execute); write_local_file(dest, size_to_write); } MSG_task_destroy(to_execute); to_execute = NULL; } storage_info(MSG_host_self()); dump_platform_storages(); return 1; } int main(int argc, char *argv[]) { MSG_init(&argc, argv); /* Check the arguments */ if (argc < 3) { printf("Usage: %s platform_file deployment_file \n", argv[0]); return -1; } const char *platform_file = argv[1]; const char *deployment_file = argv[2]; MSG_create_environment(platform_file); MSG_function_register("client", client); MSG_function_register("server", server); MSG_launch_application(deployment_file); msg_error_t res = MSG_main(); XBT_INFO("Simulated time: %g", MSG_get_clock()); if (res == MSG_OK) return 0; else return 1; } SimGrid-3.11/teshsuite/msg/storage/storage_content_c.txt000644 001750 001750 00000000541 12342443666 022546 0ustar00cici000000 000000 /doc/simgrid/examples/cxx/autoDestination/FinalizeTask.cxx 500001 /doc/simgrid/examples/cxx/autoDestination/autoDestination_deployment.xml 800000 /doc/simgrid/examples/cxx/autoDestination/Main.cxx 75000000 /doc/simgrid/examples/cxx/autoDestination/Slave.cxx 45800000 /doc/simgrid/examples/cxx/autoDestination/BasicTask.cxx 400000 SimGrid-3.11/teshsuite/msg/storage/storage_content_s1.txt000644 001750 001750 00000000406 12342443666 022647 0ustar00cici000000 000000 /doc/simgrid/examples/cxx/autoDestination/Master.cxx 10 /doc/simgrid/examples/cxx/autoDestination/autoDestination_platform.xml 10 /doc/simgrid/examples/cxx/autoDestination/Forwarder.cxx 10 /doc/simgrid/examples/cxx/basic/FinalizeTask.cxx 10 SimGrid-3.11/teshsuite/msg/storage/platform.xml000644 001750 001750 00000003501 12342443670 020645 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/storage/storage_basic.tesh000644 001750 001750 00000011543 12342443664 022001 0ustar00cici000000 000000 $ ./storage_basic$EXEEXT --cfg=path:${srcdir:=.} ${srcdir:=.}/platform.xml ${srcdir:=.}/deployment.xml 0 "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (1:server@server) *** Storage info on server *** > [ 0.000000] (1:server@server) Storage name: sdisk1, mount name: /sd1 > [ 0.000000] (1:server@server) Free size: 322122547160 bytes > [ 0.000000] (1:server@server) Used size: 40 bytes > [ 0.000000] (1:server@server) Properties of mounted storage: sdisk1 > [ 0.000000] (1:server@server) 'usage' -> 'File system' > [ 0.000000] (1:server@server) *** Dump a storage element *** > [ 0.000000] (1:server@server) Print the content of the storage element: sdisk1 > [ 0.000000] (1:server@server) /doc/simgrid/examples/cxx/autoDestination/Master.cxx size: 10 bytes > [ 0.000000] (1:server@server) /doc/simgrid/examples/cxx/basic/FinalizeTask.cxx size: 10 bytes > [ 0.000000] (1:server@server) /doc/simgrid/examples/cxx/autoDestination/Forwarder.cxx size: 10 bytes > [ 0.000000] (1:server@server) /doc/simgrid/examples/cxx/autoDestination/autoDestination_platform.xml size: 10 bytes > [ 0.000000] (1:server@server) Storage name: sdisk2, mount name: /sd2 > [ 0.000000] (1:server@server) Free size: 805306367980 bytes > [ 0.000000] (1:server@server) Used size: 20 bytes > [ 0.000000] (1:server@server) Properties of mounted storage: sdisk2 > [ 0.000000] (1:server@server) 'usage' -> 'Cache' > [ 0.000000] (1:server@server) *** Dump a storage element *** > [ 0.000000] (1:server@server) Print the content of the storage element: sdisk2 > [ 0.000000] (1:server@server) /doc/simgrid/examples/cxx/basic/Main.cxx size: 10 bytes > [ 0.000000] (1:server@server) /doc/simgrid/examples/cxx/basic/Slave.cxx size: 10 bytes > [ 0.000000] (1:server@server) Server waiting for transfers ... > [ 0.005000] (2:client@client) client has read 500001 on /sd1/doc/simgrid/examples/cxx/autoDestination/FinalizeTask.cxx > [ 0.005000] (2:client@client) client sends 500001 to server > [ 0.026647] (1:server@server) 500001 bytes on 500001 bytes have been written by server on /sd1 > [ 0.417980] (2:client@client) client has read 800000 on /sd1/doc/simgrid/examples/cxx/autoDestination/autoDestination_deployment.xml > [ 0.417980] (2:client@client) client sends 800000 to server > [ 0.452225] (1:server@server) 800000 bytes on 800000 bytes have been written by server on /sd1 > [ 1.283559] (2:client@client) client has read 45800000 on /sd1/doc/simgrid/examples/cxx/autoDestination/Slave.cxx > [ 1.283559] (2:client@client) client sends 45800000 to server > [ 3.207494] (1:server@server) 45800000 bytes on 45800000 bytes have been written by server on /sd1 > [ 3.208145] (2:client@client) *** GET/SET DATA for storage element: cdisk *** > [ 3.208145] (2:client@client) Get data: '(null)' > [ 3.208145] (2:client@client) Set and get data: 'Some data' > [ 3.208145] (1:server@server) *** Storage info on server *** > [ 3.208145] (1:server@server) Storage name: sdisk1, mount name: /sd1 > [ 3.208145] (1:server@server) Free size: 322122547160 bytes > [ 3.208145] (1:server@server) Used size: 40 bytes > [ 3.208145] (1:server@server) Properties of mounted storage: sdisk1 > [ 3.208145] (1:server@server) 'usage' -> 'File system' > [ 3.208145] (1:server@server) *** Dump a storage element *** > [ 3.208145] (1:server@server) Print the content of the storage element: sdisk1 > [ 3.208145] (1:server@server) /doc/simgrid/examples/cxx/autoDestination/Master.cxx size: 10 bytes > [ 3.208145] (1:server@server) /doc/simgrid/examples/cxx/basic/FinalizeTask.cxx size: 10 bytes > [ 3.208145] (1:server@server) /doc/simgrid/examples/cxx/autoDestination/Forwarder.cxx size: 10 bytes > [ 3.208145] (1:server@server) /doc/simgrid/examples/cxx/autoDestination/autoDestination_platform.xml size: 10 bytes > [ 3.208145] (1:server@server) Storage name: sdisk2, mount name: /sd2 > [ 3.208145] (1:server@server) Free size: 805259267979 bytes > [ 3.208145] (1:server@server) Used size: 47100021 bytes > [ 3.208145] (1:server@server) Properties of mounted storage: sdisk2 > [ 3.208145] (1:server@server) 'usage' -> 'Cache' > [ 3.208145] (1:server@server) *** Dump a storage element *** > [ 3.208145] (1:server@server) Print the content of the storage element: sdisk2 > [ 3.208145] (1:server@server) /scratch/titi.xml size: 800000 bytes > [ 3.208145] (1:server@server) /scratch/tata.cxx size: 45800000 bytes > [ 3.208145] (1:server@server) /doc/simgrid/examples/cxx/basic/Main.cxx size: 10 bytes > [ 3.208145] (1:server@server) /scratch/toto.cxx size: 500001 bytes > [ 3.208145] (1:server@server) /doc/simgrid/examples/cxx/basic/Slave.cxx size: 10 bytes > [ 3.208145] (1:server@server) Storage cdisk is attached to client > [ 3.208145] (1:server@server) Storage sdisk1 is attached to server > [ 3.208145] (1:server@server) Storage sdisk2 is attached to server > [ 3.208145] (0:@) Simulated time: 3.20814 SimGrid-3.11/teshsuite/msg/storage/storage_content_s2.txt000644 001750 001750 00000000133 12342443666 022645 0ustar00cici000000 000000 /doc/simgrid/examples/cxx/basic/Main.cxx 10 /doc/simgrid/examples/cxx/basic/Slave.cxx 10 SimGrid-3.11/teshsuite/msg/storage/CMakeLists.txt000644 001750 001750 00000001605 12342443654 021044 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(storage_basic storage_basic.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(storage_basic simgrid m pthread ) else() target_link_libraries(storage_basic simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/storage_basic.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/platform.xml ${CMAKE_CURRENT_SOURCE_DIR}/deployment.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/storage_basic.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/storage_content_c.txt ${CMAKE_CURRENT_SOURCE_DIR}/storage_content_s1.txt ${CMAKE_CURRENT_SOURCE_DIR}/storage_content_s2.txt PARENT_SCOPE ) SimGrid-3.11/teshsuite/msg/process/000755 001750 001750 00000000000 12342443670 016312 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/process/process.tesh000644 001750 001750 00000002306 12342443664 020661 0ustar00cici000000 000000 $ ./process ${srcdir:=.}/process_p.xml ${srcdir:=.}/process_d.xml > [Tremblay:slave:(2) 0.500000] [msg_test/INFO] Slave started (PID:2, PPID:0) > [Tremblay:slave:(2) 0.500000] [msg_test/INFO] Plop i am not suspended > [Tremblay:master:(1) 1.000000] [msg_test/INFO] Process(pid=1, ppid=0, name=master) > [Tremblay:master:(1) 1.000000] [msg_test/INFO] Process(pid=2, ppid=0, name=slave) > [Tremblay:slave from master:(3) 1.500000] [msg_test/INFO] Slave started (PID:3, PPID:1) > [Tremblay:slave from master:(3) 1.500000] [msg_test/INFO] Plop i am not suspended > [Tremblay:slave from master:(3) 2.500000] [msg_test/INFO] Plop i am not suspended > [Tremblay:master:(1) 3.000000] [msg_test/INFO] Suspend Process(pid=3) > [Tremblay:master:(1) 3.000000] [msg_test/INFO] Process(pid=3) is suspended > [Tremblay:master:(1) 5.000000] [msg_test/INFO] Resume Process(pid=3) > [Tremblay:master:(1) 5.000000] [msg_test/INFO] Process(pid=3) is not suspended > [Tremblay:slave from master:(3) 5.000000] [msg_test/INFO] Plop i am not suspended > [Tremblay:slave from master:(3) 6.000000] [msg_test/INFO] Plop i am not suspended > [Tremblay:master:(1) 7.000000] [msg_test/INFO] Goodbye now! > [7.000000] [msg_test/INFO] Simulation time 7 SimGrid-3.11/teshsuite/msg/process/process.c000644 001750 001750 00000006544 12342443665 020151 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include "msg/msg.h" /* Yeah! If you want to use msg, you need to include msg/msg.h */ #include "xbt/sysdep.h" /* calloc, printf */ /* Create a log channel to have nice outputs. */ #include "xbt/log.h" #include "xbt/asserts.h" XBT_LOG_NEW_DEFAULT_CATEGORY(msg_test, "Messages specific for this msg example"); int master(int argc, char *argv[]); int slave(int argc, char *argv[]); /** Emitter function */ int master(int argc, char *argv[]) { xbt_swag_t process_list = MSG_host_get_process_list(MSG_host_self()); msg_process_t process = NULL; MSG_process_sleep(1); xbt_swag_foreach(process, process_list) { XBT_INFO("Process(pid=%d, ppid=%d, name=%s)", MSG_process_get_PID(process), MSG_process_get_PPID(process), MSG_process_get_name(process)); if (MSG_process_self_PID() != MSG_process_get_PID(process)) MSG_process_kill(process); } process = MSG_process_create("slave from master", slave, NULL, MSG_host_self()); MSG_process_sleep(2); XBT_INFO("Suspend Process(pid=%d)", MSG_process_get_PID(process)); MSG_process_suspend(process); XBT_INFO("Process(pid=%d) is %ssuspended", MSG_process_get_PID(process), (MSG_process_is_suspended(process)) ? "" : "not "); MSG_process_sleep(2); XBT_INFO("Resume Process(pid=%d)", MSG_process_get_PID(process)); MSG_process_resume(process); XBT_INFO("Process(pid=%d) is %ssuspended", MSG_process_get_PID(process), (MSG_process_is_suspended(process)) ? "" : "not "); MSG_process_sleep(2); MSG_process_kill(process); XBT_INFO("Goodbye now!"); return 0; } /* end_of_master */ /** Receiver function */ int slave(int argc, char *argv[]) { MSG_process_sleep(.5); XBT_INFO("Slave started (PID:%d, PPID:%d)", MSG_process_self_PID(), MSG_process_self_PPID()); while(1){ XBT_INFO("Plop i am %ssuspended", (MSG_process_is_suspended(MSG_process_self())) ? "" : "not "); MSG_process_sleep(1); } XBT_INFO("I'm done. See you!"); return 0; } /* end_of_slave */ /** Main function */ int main(int argc, char *argv[]) { msg_error_t res; const char *platform_file; const char *application_file; MSG_init(&argc, argv); if (argc != 3) { printf("Usage: %s platform_file deployment_file\n", argv[0]); printf("example: %s msg_platform.xml msg_deployment.xml\n", argv[0]); exit(1); } platform_file = argv[1]; application_file = argv[2]; /* MSG_config("workstation/model","KCCFLN05"); */ { /* Simulation setting */ MSG_create_environment(platform_file); } { /* Application deployment */ MSG_function_register("master", master); MSG_function_register("slave", slave); MSG_launch_application(application_file); } res = MSG_main(); XBT_INFO("Simulation time %g", MSG_get_clock()); if (res == MSG_OK) return 0; else return 1; } /* end_of_main */ SimGrid-3.11/teshsuite/msg/process/process_p.xml000644 001750 001750 00000000350 12342443670 021027 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/process/process_d.xml000644 001750 001750 00000000561 12342443667 021025 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/process/CMakeLists.txt000644 001750 001750 00000001160 12342443654 021052 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(process process.c) ### Add definitions for compile target_link_libraries(process simgrid) set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/process.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/process_d.xml ${CMAKE_CURRENT_SOURCE_DIR}/process_p.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/process.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/msg/host_on_off/000755 001750 001750 00000000000 12342443667 017145 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/host_on_off/host_on_off_d.xml000644 001750 001750 00000000561 12342443667 022477 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/host_on_off/host_on_off.c000644 001750 001750 00000007542 12342443665 021622 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include "msg/msg.h" /* Yeah! If you want to use msg, you need to include msg/msg.h */ #include "xbt/sysdep.h" /* calloc, printf */ /* Create a log channel to have nice outputs. */ #include "xbt/log.h" #include "xbt/asserts.h" XBT_LOG_NEW_DEFAULT_CATEGORY(msg_test, "Messages specific for this msg example"); int master(int argc, char *argv[]); int slave(int argc, char *argv[]); /** Emitter function */ int master(int argc, char *argv[]) { double task_comp_size = 5E7; double task_comm_size = 1E6; char mailbox[256]; msg_task_t task = NULL; sprintf(mailbox, "jupi"); task = MSG_task_create("task on", task_comp_size, task_comm_size, NULL); XBT_INFO("Sending \"%s\"", task->name); if (MSG_task_send_with_timeout(task, mailbox, 1) != MSG_OK) MSG_task_destroy(task); MSG_process_sleep(1); MSG_host_off(MSG_get_host_by_name("Jupiter")); task = MSG_task_create("task off", task_comp_size, task_comm_size, NULL); XBT_INFO("Sending \"%s\"", task->name); if (MSG_task_send_with_timeout(task, mailbox, 1) != MSG_OK) MSG_task_destroy(task); MSG_host_on(MSG_get_host_by_name("Jupiter")); task = MSG_task_create("task on without proc", task_comp_size, task_comm_size, NULL); XBT_INFO("Sending \"%s\"", task->name); if (MSG_task_send_with_timeout(task, mailbox, 1) != MSG_OK) MSG_task_destroy(task); char **argvF = xbt_new(char*, 2); argvF[0] = xbt_strdup("slave"); MSG_process_create_with_arguments("slave", slave, NULL, MSG_get_host_by_name("Jupiter"), 1, argvF); task = MSG_task_create("task on with proc", task_comp_size, task_comm_size, NULL); XBT_INFO("Sending \"%s\"", task->name); if (MSG_task_send_with_timeout(task, mailbox, 1) != MSG_OK) MSG_task_destroy(task); task = MSG_task_create("finalize", 0, 0, 0); XBT_INFO("Sending \"%s\"", task->name); if (MSG_task_send_with_timeout(task, mailbox, 1) != MSG_OK) MSG_task_destroy(task); XBT_INFO("Goodbye now!"); return 0; } /* end_of_master */ /** Receiver function */ int slave(int argc, char *argv[]) { msg_task_t task = NULL; _XBT_GNUC_UNUSED int res; int id = -1; char mailbox[80]; sprintf(mailbox, "jupi"); while (1) { res = MSG_task_receive(&(task), mailbox); xbt_assert(res == MSG_OK, "MSG_task_get failed"); if (!strcmp(MSG_task_get_name(task), "finalize")) { MSG_task_destroy(task); break; } MSG_task_execute(task); XBT_INFO("Task \"%s\" done", MSG_task_get_name(task)); MSG_task_destroy(task); task = NULL; id--; } XBT_INFO("I'm done. See you!"); return 0; } /* end_of_slave */ /** Main function */ int main(int argc, char *argv[]) { msg_error_t res; const char *platform_file; const char *application_file; MSG_init(&argc, argv); if (argc != 3) { printf("Usage: %s platform_file deployment_file\n", argv[0]); printf("example: %s msg_platform.xml msg_deployment.xml\n", argv[0]); exit(1); } platform_file = argv[1]; application_file = argv[2]; /* MSG_config("workstation/model","KCCFLN05"); */ { /* Simulation setting */ MSG_create_environment(platform_file); } { /* Application deployment */ MSG_function_register("master", master); MSG_function_register("slave", slave); MSG_launch_application(application_file); } res = MSG_main(); XBT_INFO("Simulation time %g", MSG_get_clock()); if (res == MSG_OK) return 0; else return 1; } /* end_of_main */ SimGrid-3.11/teshsuite/msg/host_on_off/host_on_off.tesh000644 001750 001750 00000001375 12342443664 022340 0ustar00cici000000 000000 $ ./host_on_off ${srcdir:=.}/host_on_off_p.xml ${srcdir:=.}/host_on_off_d.xml > [Tremblay:master:(1) 0.000000] [msg_test/INFO] Sending "task on" > [Jupiter:slave:(2) 0.682345] [msg_test/INFO] Task "task on" done > [Tremblay:master:(1) 1.027003] [msg_test/INFO] Sending "task off" > [Tremblay:master:(1) 2.027003] [msg_test/INFO] Sending "task on without proc" > [Tremblay:master:(1) 3.027003] [msg_test/INFO] Sending "task on with proc" > [Tremblay:master:(1) 3.054005] [msg_test/INFO] Sending "finalize" > [Jupiter:slave:(3) 3.709348] [msg_test/INFO] Task "task on with proc" done > [Tremblay:master:(1) 3.710127] [msg_test/INFO] Goodbye now! > [Jupiter:slave:(3) 3.710127] [msg_test/INFO] I'm done. See you! > [3.710127] [msg_test/INFO] Simulation time 3.71013 SimGrid-3.11/teshsuite/msg/host_on_off/host_on_off_p.xml000644 001750 001750 00000000634 12342443667 022514 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/host_on_off/CMakeLists.txt000644 001750 001750 00000001214 12342443654 021677 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(host_on_off host_on_off.c) ### Add definitions for compile target_link_libraries(host_on_off simgrid) set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/host_on_off.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/host_on_off_d.xml ${CMAKE_CURRENT_SOURCE_DIR}/host_on_off_p.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/host_on_off.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/msg/task_destroy_cancel/000755 001750 001750 00000000000 12342443670 020654 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/task_destroy_cancel/task_destroy_cancel_p.xml000644 001750 001750 00000000634 12342443670 025740 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/task_destroy_cancel/task_destroy_cancel.c000644 001750 001750 00000011560 12342443665 025047 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include "msg/msg.h" /* Yeah! If you want to use msg, you need to include msg/msg.h */ #include "xbt/sysdep.h" /* calloc, printf */ /* Create a log channel to have nice outputs. */ #include "xbt/log.h" #include "xbt/asserts.h" XBT_LOG_NEW_DEFAULT_CATEGORY(msg_test, "Messages specific for this msg example"); int master(int argc, char *argv[]); int slave(int argc, char *argv[]); /** Emitter function */ int master(int argc, char *argv[]) { double task_comp_size = 5E7; double task_comm_size = 1E6; double timeout = 1; char mailbox[256]; msg_task_t task = NULL; msg_comm_t comm = NULL; xbt_ex_t ex; sprintf(mailbox, "jupi"); task = MSG_task_create("normal", task_comp_size, task_comm_size, NULL); XBT_INFO("Sending task: \"%s\"", task->name); MSG_task_send_with_timeout(task, mailbox, timeout); task = MSG_task_create("cancel directly", task_comp_size, task_comm_size, NULL); XBT_INFO("Canceling task \"%s\" directly", task->name); MSG_task_cancel(task); MSG_task_destroy(task); task = MSG_task_create("destroy directly", task_comp_size, task_comm_size, NULL); XBT_INFO("Destroying task \"%s\" directly", task->name); MSG_task_destroy(task); task = MSG_task_create("cancel", task_comp_size, task_comm_size, NULL); comm = MSG_task_isend(task, mailbox); XBT_INFO("Canceling task \"%s\" during comm", task->name); MSG_task_cancel(task); TRY { MSG_comm_wait(comm, -1); } CATCH (ex) { xbt_ex_free(ex); MSG_comm_destroy(comm); } MSG_task_destroy(task); task = MSG_task_create("finalize", task_comp_size, task_comm_size, NULL); comm = MSG_task_isend(task, mailbox); XBT_INFO("Destroying task \"%s\" during comm", task->name); MSG_task_destroy(task); TRY { MSG_comm_wait(comm, -1); } CATCH (ex) { xbt_ex_free(ex); MSG_comm_destroy(comm); } task = MSG_task_create("cancel", task_comp_size, task_comm_size, NULL); MSG_task_send_with_timeout(task, mailbox, timeout); task = MSG_task_create("finalize", task_comp_size, task_comm_size, NULL); MSG_task_send_with_timeout(task, mailbox, timeout); XBT_INFO("Goodbye now!"); return 0; } /* end_of_master */ static int worker_main(int argc, char *argv[]) { msg_task_t task = MSG_process_get_data(MSG_process_self()); msg_error_t res; XBT_INFO("Start %s", task->name); res = MSG_task_execute(task); XBT_INFO("Task %s", res == MSG_OK ? "done" : "failed"); MSG_task_destroy(task); return 0; } /** Receiver function */ int slave(int argc, char *argv[]) { msg_task_t task; _XBT_GNUC_UNUSED int res; int id = -1; char mailbox[80]; double start, end; sprintf(mailbox, "jupi"); while (1) { task = NULL; res = MSG_task_receive(&(task), mailbox); xbt_assert(res == MSG_OK, "MSG_task_get failed"); XBT_INFO("Handling task \"%s\"", MSG_task_get_name(task)); if (!strcmp(MSG_task_get_name(task), "finalize")) { XBT_INFO("Destroying task \"%s\"", task->name); MSG_task_destroy(task); break; } if (!strcmp(MSG_task_get_name(task), "cancel")) { MSG_process_create("worker1", worker_main, task, MSG_host_self()); MSG_process_sleep(0.1); XBT_INFO("Canceling task \"%s\"", task->name); MSG_task_cancel(task); continue; } start = MSG_get_clock(); MSG_task_execute(task); end = MSG_get_clock(); XBT_INFO("Task \"%s\" done in %f (amount %f)" , MSG_task_get_name(task) , end - start , MSG_task_get_remaining_computation(task)); MSG_task_destroy(task); task = NULL; id--; } XBT_INFO("I'm done. See you!"); return 0; } /* end_of_slave */ /** Main function */ int main(int argc, char *argv[]) { msg_error_t res; const char *platform_file; const char *application_file; MSG_init(&argc, argv); if (argc != 3) { printf("Usage: %s platform_file deployment_file\n", argv[0]); printf("example: %s msg_platform.xml msg_deployment.xml\n", argv[0]); exit(1); } platform_file = argv[1]; application_file = argv[2]; /* MSG_config("workstation/model","KCCFLN05"); */ { /* Simulation setting */ MSG_create_environment(platform_file); } { /* Application deployment */ MSG_function_register("master", master); MSG_function_register("slave", slave); MSG_launch_application(application_file); } res = MSG_main(); XBT_INFO("Simulation time %g", MSG_get_clock()); if (res == MSG_OK) return 0; else return 1; } /* end_of_main */ SimGrid-3.11/teshsuite/msg/task_destroy_cancel/task_destroy_cancel_d.xml000644 001750 001750 00000000561 12342443670 025723 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/task_destroy_cancel/task_destroy_cancel.tesh000644 001750 001750 00000002411 12342443664 025562 0ustar00cici000000 000000 $ ./task_destroy_cancel ${srcdir:=.}/task_destroy_cancel_p.xml ${srcdir:=.}/task_destroy_cancel_d.xml > [Tremblay:master:(1) 0.000000] [msg_test/INFO] Sending task: "normal" > [Jupiter:slave:(2) 0.027003] [msg_test/INFO] Handling task "normal" > [Tremblay:master:(1) 0.027003] [msg_test/INFO] Canceling task "cancel directly" directly > [Tremblay:master:(1) 0.027003] [msg_test/INFO] Destroying task "destroy directly" directly > [Tremblay:master:(1) 0.027003] [msg_test/INFO] Canceling task "cancel" during comm > [Tremblay:master:(1) 0.027003] [msg_test/INFO] Destroying task "finalize" during comm > [Jupiter:slave:(2) 0.682345] [msg_test/INFO] Task "normal" done in 0.655342 (amount 0.000000) > [Jupiter:slave:(2) 0.709348] [msg_test/INFO] Handling task "cancel" > [Jupiter:worker1:(3) 0.709348] [msg_test/INFO] Start cancel > [Jupiter:slave:(2) 0.809348] [msg_test/INFO] Canceling task "cancel" > [Jupiter:worker1:(3) 0.810127] [msg_test/INFO] Task failed > [Tremblay:master:(1) 0.836350] [msg_test/INFO] Goodbye now! > [Jupiter:slave:(2) 0.836350] [msg_test/INFO] Handling task "finalize" > [Jupiter:slave:(2) 0.836350] [msg_test/INFO] Destroying task "finalize" > [Jupiter:slave:(2) 0.836350] [msg_test/INFO] I'm done. See you! > [0.836350] [msg_test/INFO] Simulation time 0.83635 SimGrid-3.11/teshsuite/msg/task_destroy_cancel/CMakeLists.txt000644 001750 001750 00000001304 12342443654 023414 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(task_destroy_cancel task_destroy_cancel.c) ### Add definitions for compile target_link_libraries(task_destroy_cancel simgrid) set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/task_destroy_cancel.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/task_destroy_cancel_d.xml ${CMAKE_CURRENT_SOURCE_DIR}/task_destroy_cancel_p.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/task_destroy_cancel.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/msg/get_sender/000755 001750 001750 00000000000 12342443667 016761 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/get_sender/get_sender.tesh000644 001750 001750 00000000467 12342443664 021771 0ustar00cici000000 000000 ! output sort $ ./get_sender ${srcdir:=.}/get_sender_p.xml ${srcdir:=.}/get_sender_d.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (1:send@toto) Sending > [ 0.000000] (2:receive@toto) Receiving > [ 0.000000] (2:receive@toto) Got a message sent by 'send' > [ 1.000000] (1:send@toto) Exiting SimGrid-3.11/teshsuite/msg/get_sender/get_sender.c000644 001750 001750 00000002734 12342443665 021250 0ustar00cici000000 000000 /* Copyright (c) 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include "msg/msg.h" #include XBT_LOG_NEW_DEFAULT_CATEGORY(test, "Messages specific to this example"); static int send(int argc, char *argv[]) { XBT_INFO("Sending"); MSG_task_send(MSG_task_create("Blah", 0.0, 0.0, NULL), MSG_host_get_name(MSG_host_self())); MSG_process_sleep(1.); /* FIXME: if the sender exits before the receiver calls get_sender(), bad thing happens */ XBT_INFO("Exiting"); return 0; } static int receive(int argc, char *argv[]) { XBT_INFO("Receiving"); msg_task_t task = NULL; MSG_task_receive_with_timeout(&task, MSG_host_get_name(MSG_host_self()), DBL_MAX); xbt_assert(MSG_task_get_sender(task), "No sender received"); XBT_INFO("Got a message sent by '%s'", MSG_process_get_name(MSG_task_get_sender(task))); MSG_task_destroy(task); return 0; } /** Main function */ int main(int argc, char *argv[]) { msg_error_t res = MSG_OK; MSG_init(&argc, argv); /* Application deployment */ MSG_function_register("send", &send); MSG_function_register("receive", &receive); MSG_create_environment(argv[1]); MSG_launch_application(argv[2]); res = MSG_main(); if (res == MSG_OK) return 0; else return 1; } SimGrid-3.11/teshsuite/msg/get_sender/get_sender_p.xml000644 001750 001750 00000000475 12342443667 022147 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/get_sender/get_sender_d.xml000644 001750 001750 00000000362 12342443667 022126 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/get_sender/CMakeLists.txt000644 001750 001750 00000001205 12342443654 021513 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(get_sender get_sender.c) ### Add definitions for compile target_link_libraries(get_sender simgrid) set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/get_sender.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/get_sender_d.xml ${CMAKE_CURRENT_SOURCE_DIR}/get_sender_p.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/get_sender.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/msg/trace/000755 001750 001750 00000000000 12342443670 015732 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/test9.xml000644 001750 001750 00000000745 12342443670 017532 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/file.trace000644 001750 001750 00000000110 12342443666 017666 0ustar00cici000000 000000 PERIODICITY 10 0 0.5 10 0.5 20 1.00 30 0.5 40 0.5 50 0.5 60 0.5 SimGrid-3.11/teshsuite/msg/trace/test6.xml000644 001750 001750 00000000403 12342443670 017516 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/test4.xml000644 001750 001750 00000000402 12342443670 017513 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/test2.xml000644 001750 001750 00000000402 12342443670 017511 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/test8.xml000644 001750 001750 00000000603 12342443670 017522 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/test11.xml000644 001750 001750 00000000711 12342443670 017574 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/test_trace_integration.c000644 001750 001750 00000003633 12342443665 022647 0ustar00cici000000 000000 /* Copyright (c) 2009-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "msg/msg.h" #include "xbt/log.h" #include "xbt/asserts.h" XBT_LOG_NEW_DEFAULT_CATEGORY(test_trace_integration, "Messages specific for this msg example"); int test_trace(int argc, char *argv[]); /** test the trace integration cpu model */ int test_trace(int argc, char *argv[]) { msg_task_t task; double task_comp_size = 2800; double task_prio = 1.0; if (argc != 3) { printf ("Wrong number of arguments!\nUsage:\n\t1) task computational size in FLOPS\n\t2 task priority\n"); exit(1); } task_comp_size = atof(argv[1]); task_prio = atof(argv[2]); XBT_INFO("Testing the trace integration cpu model: CpuTI"); XBT_INFO("Task size: %f", task_comp_size); XBT_INFO("Task prio: %f", task_prio); /* Create and execute a single task. */ task = MSG_task_create("proc 0", task_comp_size, 0, NULL); MSG_task_set_priority(task, task_prio); MSG_task_execute(task); MSG_task_destroy(task); XBT_INFO("Test finished"); return 0; } /** Main function */ int main(int argc, char *argv[]) { msg_error_t res = MSG_OK; /* Verify if the platform xml file was passed by command line. */ MSG_init(&argc, argv); if (argc < 2) { printf("Usage: %s test_trace_integration_model.xml\n", argv[0]); exit(1); } /* Register SimGrid process function. */ MSG_function_register("test_trace", test_trace); /* Use the same file for platform and deployment. */ MSG_create_environment(argv[1]); MSG_launch_application(argv[2]); /* Run the example. */ res = MSG_main(); if (res == MSG_OK) return 0; else return 1; } SimGrid-3.11/teshsuite/msg/trace/test3.xml000644 001750 001750 00000000403 12342443670 017513 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/test1.xml000644 001750 001750 00000000401 12342443670 017507 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/test5.xml000644 001750 001750 00000000402 12342443670 017514 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/platform.xml000644 001750 001750 00000000351 12342443670 020277 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/platform_trace.xml000644 001750 001750 00000000545 12342443670 021462 0ustar00cici000000 000000 0 0.5 10 0.5 20 1.00 30 0.5 40 0.5 50 0.5 60 0.5 SimGrid-3.11/teshsuite/msg/trace/test10.xml000644 001750 001750 00000000744 12342443670 017601 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/trace.tesh000644 001750 001750 00000024636 12342443664 017733 0ustar00cici000000 000000 #! ./tesh p Testing trace integration using file.trace and test1.xml, a < max(time), b < max(time) ! output sort $ $SG_TEST_EXENV ${bindir:=.}/test_trace_integration$EXEEXT ./platform.xml ./test1.xml --cfg=workstation/model:compound --cfg=network/model:CM02 --cfg=cpu/optim:TI "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'workstation/model' to 'compound' > [ 0.000000] (0:@) Configuration change: Set 'network/model' to 'CM02' > [ 0.000000] (0:@) Configuration change: Set 'cpu/optim' to 'TI' > [ 10.000000] (1:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 10.000000] (1:test_trace@CPU1) Task size: 400.000000 > [ 10.000000] (1:test_trace@CPU1) Task prio: 1.000000 > [ 40.000000] (1:test_trace@CPU1) Test finished p Testing trace integration using file.trace and test2.xml, a < max(time), max(time) < b < 2 max(time) ! output sort $ $SG_TEST_EXENV ${bindir:=.}/test_trace_integration$EXEEXT ./platform.xml ./test2.xml --cfg=workstation/model:compound --cfg=network/model:CM02 --cfg=cpu/optim:TI "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'workstation/model' to 'compound' > [ 0.000000] (0:@) Configuration change: Set 'network/model' to 'CM02' > [ 0.000000] (0:@) Configuration change: Set 'cpu/optim' to 'TI' > [ 10.000000] (1:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 10.000000] (1:test_trace@CPU1) Task size: 850.000000 > [ 10.000000] (1:test_trace@CPU1) Task prio: 1.000000 > [ 85.000000] (1:test_trace@CPU1) Test finished p Testing trace integration using file.trace and test3.xml, a < max(time), b > 2 max(time) ! output sort $ $SG_TEST_EXENV ${bindir:=.}/test_trace_integration$EXEEXT ./platform.xml ./test3.xml --cfg=workstation/model:compound --cfg=network/model:CM02 --cfg=cpu/optim:TI "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'workstation/model' to 'compound' > [ 0.000000] (0:@) Configuration change: Set 'network/model' to 'CM02' > [ 0.000000] (0:@) Configuration change: Set 'cpu/optim' to 'TI' > [ 10.000000] (1:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 10.000000] (1:test_trace@CPU1) Task size: 1980.000000 > [ 10.000000] (1:test_trace@CPU1) Task prio: 1.000000 > [178.000000] (1:test_trace@CPU1) Test finished p Testing trace integration using file.trace and test4.xml, max(time) < a < 2max(time), max(time) < b < 2max(time) ! output sort $ $SG_TEST_EXENV ${bindir:=.}/test_trace_integration$EXEEXT ./platform.xml ./test4.xml --cfg=workstation/model:compound --cfg=network/model:CM02 --cfg=cpu/optim:TI "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'workstation/model' to 'compound' > [ 0.000000] (0:@) Configuration change: Set 'network/model' to 'CM02' > [ 0.000000] (0:@) Configuration change: Set 'cpu/optim' to 'TI' > [ 80.000000] (1:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 80.000000] (1:test_trace@CPU1) Task size: 400.000000 > [ 80.000000] (1:test_trace@CPU1) Task prio: 1.000000 > [110.000000] (1:test_trace@CPU1) Test finished p Testing trace integration using file.trace and test5.xml, max(time) < a < 2max(time), 2max(time) < b < 3max(time) ! output sort $ $SG_TEST_EXENV ${bindir:=.}/test_trace_integration$EXEEXT ./platform.xml ./test5.xml --cfg=workstation/model:compound --cfg=network/model:CM02 --cfg=cpu/optim:TI "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'workstation/model' to 'compound' > [ 0.000000] (0:@) Configuration change: Set 'network/model' to 'CM02' > [ 0.000000] (0:@) Configuration change: Set 'cpu/optim' to 'TI' > [ 90.000000] (1:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 90.000000] (1:test_trace@CPU1) Task size: 850.000000 > [ 90.000000] (1:test_trace@CPU1) Task prio: 1.000000 > [162.500000] (1:test_trace@CPU1) Test finished p Testing trace integration using file.trace and test6.xml, max(time) < a < 2max(time), b > 3max(time) ! output sort $ $SG_TEST_EXENV ${bindir:=.}/test_trace_integration$EXEEXT ./platform.xml ./test6.xml --cfg=workstation/model:compound --cfg=network/model:CM02 --cfg=cpu/optim:TI "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'workstation/model' to 'compound' > [ 0.000000] (0:@) Configuration change: Set 'network/model' to 'CM02' > [ 0.000000] (0:@) Configuration change: Set 'cpu/optim' to 'TI' > [ 80.000000] (1:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 80.000000] (1:test_trace@CPU1) Task size: 1980.000000 > [ 80.000000] (1:test_trace@CPU1) Task prio: 1.000000 > [248.000000] (1:test_trace@CPU1) Test finished p Testing trace integration using file.trace and test7.xml, two process with same priority ! output sort $ $SG_TEST_EXENV ${bindir:=.}/test_trace_integration$EXEEXT ./platform.xml ./test7.xml --cfg=workstation/model:compound --cfg=network/model:CM02 --cfg=cpu/optim:TI "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'workstation/model' to 'compound' > [ 0.000000] (0:@) Configuration change: Set 'network/model' to 'CM02' > [ 0.000000] (0:@) Configuration change: Set 'cpu/optim' to 'TI' > [ 10.000000] (1:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 10.000000] (1:test_trace@CPU1) Task size: 400.000000 > [ 10.000000] (1:test_trace@CPU1) Task prio: 1.500000 > [ 20.000000] (2:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 20.000000] (2:test_trace@CPU1) Task size: 300.000000 > [ 20.000000] (2:test_trace@CPU1) Task prio: 1.500000 > [ 70.000000] (1:test_trace@CPU1) Test finished > [ 70.000000] (2:test_trace@CPU1) Test finished p Testing trace integration using file.trace and test8.xml, two process with different priority ! output sort $ $SG_TEST_EXENV ${bindir:=.}/test_trace_integration$EXEEXT ./platform.xml ./test8.xml --cfg=workstation/model:compound --cfg=network/model:CM02 --cfg=cpu/optim:TI "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'workstation/model' to 'compound' > [ 0.000000] (0:@) Configuration change: Set 'network/model' to 'CM02' > [ 0.000000] (0:@) Configuration change: Set 'cpu/optim' to 'TI' > [ 10.000000] (1:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 10.000000] (1:test_trace@CPU1) Task size: 400.000000 > [ 10.000000] (1:test_trace@CPU1) Task prio: 2.500000 > [ 10.000000] (2:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 10.000000] (2:test_trace@CPU1) Task size: 400.000000 > [ 10.000000] (2:test_trace@CPU1) Task prio: 1.000000 > [ 56.000000] (1:test_trace@CPU1) Test finished > [ 80.000000] (2:test_trace@CPU1) Test finished p Testing trace integration using file.trace and test9.xml, three process with same priority ! output sort $ $SG_TEST_EXENV ${bindir:=.}/test_trace_integration$EXEEXT ./platform.xml ./test9.xml --cfg=workstation/model:compound --cfg=network/model:CM02 --cfg=cpu/optim:TI "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'workstation/model' to 'compound' > [ 0.000000] (0:@) Configuration change: Set 'network/model' to 'CM02' > [ 0.000000] (0:@) Configuration change: Set 'cpu/optim' to 'TI' > [ 0.000000] (1:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 0.000000] (1:test_trace@CPU1) Task size: 400.000000 > [ 0.000000] (1:test_trace@CPU1) Task prio: 1.000000 > [ 0.000000] (2:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 0.000000] (2:test_trace@CPU1) Task size: 400.000000 > [ 0.000000] (2:test_trace@CPU1) Task prio: 1.000000 > [ 30.000000] (3:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 30.000000] (3:test_trace@CPU1) Task size: 2000.000000 > [ 30.000000] (3:test_trace@CPU1) Task prio: 1.000000 > [ 90.000000] (1:test_trace@CPU1) Test finished > [ 90.000000] (2:test_trace@CPU1) Test finished > [240.000000] (3:test_trace@CPU1) Test finished p Testing trace integration using file.trace and test10.xml, three process with different priority ! output sort $ $SG_TEST_EXENV ${bindir:=.}/test_trace_integration$EXEEXT ./platform.xml ./test10.xml --cfg=workstation/model:compound --cfg=network/model:CM02 --cfg=cpu/optim:TI "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'workstation/model' to 'compound' > [ 0.000000] (0:@) Configuration change: Set 'network/model' to 'CM02' > [ 0.000000] (0:@) Configuration change: Set 'cpu/optim' to 'TI' > [ 0.000000] (1:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 0.000000] (1:test_trace@CPU1) Task size: 420.000000 > [ 0.000000] (1:test_trace@CPU1) Task prio: 2.000000 > [ 0.000000] (2:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 0.000000] (2:test_trace@CPU1) Task size: 310.000000 > [ 0.000000] (2:test_trace@CPU1) Task prio: 1.000000 > [ 50.000000] (3:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 50.000000] (3:test_trace@CPU1) Task size: 990.000000 > [ 50.000000] (3:test_trace@CPU1) Task prio: 9.000000 > [ 62.000000] (1:test_trace@CPU1) Test finished > [152.000000] (2:test_trace@CPU1) Test finished > [152.000000] (3:test_trace@CPU1) Test finished p Testing trace integration using file.trace and test11.xml, three process with different priority. Changed timestep to 0.1. ! output sort $ $SG_TEST_EXENV ${bindir:=.}/test_trace_integration$EXEEXT ./platform_trace.xml ./test11.xml --cfg=workstation/model:compound --cfg=network/model:CM02 --cfg=cpu/optim:TI "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'workstation/model' to 'compound' > [ 0.000000] (0:@) Configuration change: Set 'network/model' to 'CM02' > [ 0.000000] (0:@) Configuration change: Set 'cpu/optim' to 'TI' > [ 0.000000] (1:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 0.000000] (1:test_trace@CPU1) Task size: 420.000000 > [ 0.000000] (1:test_trace@CPU1) Task prio: 2.000000 > [ 0.000000] (2:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 0.000000] (2:test_trace@CPU1) Task size: 310.000000 > [ 0.000000] (2:test_trace@CPU1) Task prio: 1.000000 > [ 50.000000] (3:test_trace@CPU1) Testing the trace integration cpu model: CpuTI > [ 50.000000] (3:test_trace@CPU1) Task size: 990.000000 > [ 50.000000] (3:test_trace@CPU1) Task prio: 9.000000 > [ 62.000000] (1:test_trace@CPU1) Test finished > [152.000000] (2:test_trace@CPU1) Test finished > [152.000000] (3:test_trace@CPU1) Test finished SimGrid-3.11/teshsuite/msg/trace/test7.xml000644 001750 001750 00000000603 12342443670 017521 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/trace/CMakeLists.txt000644 001750 001750 00000002221 12342443654 020471 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(test_trace_integration test_trace_integration.c) ### Add definitions for compile target_link_libraries(test_trace_integration simgrid) set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/trace.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/platform.xml ${CMAKE_CURRENT_SOURCE_DIR}/platform_trace.xml ${CMAKE_CURRENT_SOURCE_DIR}/test10.xml ${CMAKE_CURRENT_SOURCE_DIR}/test11.xml ${CMAKE_CURRENT_SOURCE_DIR}/test1.xml ${CMAKE_CURRENT_SOURCE_DIR}/test2.xml ${CMAKE_CURRENT_SOURCE_DIR}/test3.xml ${CMAKE_CURRENT_SOURCE_DIR}/test4.xml ${CMAKE_CURRENT_SOURCE_DIR}/test5.xml ${CMAKE_CURRENT_SOURCE_DIR}/test6.xml ${CMAKE_CURRENT_SOURCE_DIR}/test7.xml ${CMAKE_CURRENT_SOURCE_DIR}/test8.xml ${CMAKE_CURRENT_SOURCE_DIR}/test9.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/test_trace_integration.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/file.trace PARENT_SCOPE ) SimGrid-3.11/teshsuite/msg/pid/000755 001750 001750 00000000000 12342443667 015416 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/pid/pid_d.xml000644 001750 001750 00000000517 12342443667 017222 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/pid/pid_p.xml000644 001750 001750 00000000521 12342443667 017231 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/pid/pid.c000644 001750 001750 00000003514 12342443665 016337 0ustar00cici000000 000000 /* Copyright (c) 2009-2010, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "msg/msg.h" #include "xbt/sysdep.h" XBT_LOG_NEW_DEFAULT_CATEGORY(msg_test, "Messages specific for this msg example"); const char* mailbox = "mailbox"; #define task_comp_size 1000 #define task_comm_size 100000 static int onexit(smx_process_exit_status_t status, int *pid){ XBT_INFO("Process \"%d\" killed.", *pid); return 0; } static int sendpid(int argc, char *argv[]) { int pid = MSG_process_self_PID(); MSG_process_on_exit((int_f_pvoid_pvoid_t)onexit, &pid); msg_task_t task = MSG_task_create("pid", task_comp_size, task_comm_size, &pid); XBT_INFO("Sending pid of \"%d\".", pid); MSG_task_send(task, mailbox); XBT_INFO("Send of pid \"%d\" done.", pid); MSG_process_suspend(MSG_process_self()); return 0; } static int killall(int argc, char *argv[]){ msg_task_t task = NULL; _XBT_GNUC_UNUSED int res; int i; for (i=0; i<3;i++) { res = MSG_task_receive(&(task), mailbox); int pid = *(int*)MSG_task_get_data(task); MSG_task_destroy(task); XBT_INFO("Killing process \"%d\".", pid); MSG_process_kill(MSG_process_from_PID(pid)); task = NULL; } return 0; } /** Main function */ int main(int argc, char *argv[]) { msg_error_t res = MSG_OK; MSG_init(&argc, argv); /* Application deployment */ MSG_function_register("sendpid", &sendpid); MSG_function_register("killall", &killall); MSG_process_killall(atoi(argv[3])); MSG_create_environment(argv[1]); MSG_launch_application(argv[2]); res = MSG_main(); if (res == MSG_OK) return 0; else return 1; } SimGrid-3.11/teshsuite/msg/pid/pid.tesh000644 001750 001750 00000002673 12342443664 017064 0ustar00cici000000 000000 $ ./pid ${srcdir:=.}/pid_p.xml ${srcdir:=.}/pid_d.xml 0 "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (1:sendpid@toto) Sending pid of "1". > [ 0.000000] (2:sendpid@toto) Sending pid of "2". > [ 0.000000] (3:sendpid@toto) Sending pid of "3". > [ 0.001082] (4:killall@toto) Killing process "1". > [ 0.001082] (1:sendpid@toto) Send of pid "1" done. > [ 0.001082] (1:sendpid@toto) Process "1" killed. > [ 0.002165] (2:sendpid@toto) Send of pid "2" done. > [ 0.002165] (4:killall@toto) Killing process "2". > [ 0.002165] (2:sendpid@toto) Process "2" killed. > [ 0.003247] (3:sendpid@toto) Send of pid "3" done. > [ 0.003247] (4:killall@toto) Killing process "3". > [ 0.003247] (3:sendpid@toto) Process "3" killed. $ ./pid ${srcdir:=.}/pid_p.xml ${srcdir:=.}/pid_d.xml 2 "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (2:sendpid@toto) Sending pid of "2". > [ 0.000000] (3:sendpid@toto) Sending pid of "3". > [ 0.000000] (4:sendpid@toto) Sending pid of "4". > [ 0.001082] (5:killall@toto) Killing process "2". > [ 0.001082] (2:sendpid@toto) Send of pid "2" done. > [ 0.001082] (2:sendpid@toto) Process "2" killed. > [ 0.002165] (3:sendpid@toto) Send of pid "3" done. > [ 0.002165] (5:killall@toto) Killing process "3". > [ 0.002165] (3:sendpid@toto) Process "3" killed. > [ 0.003247] (4:sendpid@toto) Send of pid "4" done. > [ 0.003247] (5:killall@toto) Killing process "4". > [ 0.003247] (4:sendpid@toto) Process "4" killed. SimGrid-3.11/teshsuite/msg/pid/CMakeLists.txt000644 001750 001750 00000001242 12342443654 020151 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(pid pid.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(pid simgrid m pthread) else() target_link_libraries(pid simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/pid.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/pid_d.xml ${CMAKE_CURRENT_SOURCE_DIR}/pid_p.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/pid.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/msg/process_join/000755 001750 001750 00000000000 12342443670 017331 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/process_join/process_join_p.xml000644 001750 001750 00000000350 12342443670 023065 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/process_join/process_join.c000644 001750 001750 00000005314 12342443665 022201 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include "msg/msg.h" /* Yeah! If you want to use msg, you need to include msg/msg.h */ #include "xbt/sysdep.h" /* calloc, printf */ /* Create a log channel to have nice outputs. */ #include "xbt/log.h" #include "xbt/asserts.h" XBT_LOG_NEW_DEFAULT_CATEGORY(msg_test, "Messages specific for this msg example"); int master(int argc, char *argv[]); int slave(int argc, char *argv[]); /** Emitter function */ int master(int argc, char *argv[]) { msg_process_t process; XBT_INFO("Start slave"); process = MSG_process_create("slave from master", slave, NULL, MSG_host_self()); XBT_INFO("Join the slave (timeout 2)"); MSG_process_join(process, 2); XBT_INFO("Start slave"); process = MSG_process_create("slave from master", slave, NULL, MSG_host_self()); XBT_INFO("Join the slave (timeout 4)"); MSG_process_join(process, 4); XBT_INFO("Start slave"); process = MSG_process_create("slave from master", slave, NULL, MSG_host_self()); XBT_INFO("Join the slave (timeout 2)"); MSG_process_join(process, 2); XBT_INFO("Goodbye now!"); MSG_process_sleep(1); XBT_INFO("Goodbye now!"); return 0; } /* end_of_master */ /** Receiver function */ int slave(int argc, char *argv[]) { XBT_INFO("Slave started"); MSG_process_sleep(3); XBT_INFO("I'm done. See you!"); return 0; } /* end_of_slave */ /** Main function */ int main(int argc, char *argv[]) { msg_error_t res; const char *platform_file; const char *application_file; MSG_init(&argc, argv); if (argc != 3) { printf("Usage: %s platform_file deployment_file\n", argv[0]); printf("example: %s msg_platform.xml msg_deployment.xml\n", argv[0]); exit(1); } platform_file = argv[1]; application_file = argv[2]; /* MSG_config("workstation/model","KCCFLN05"); */ { /* Simulation setting */ MSG_create_environment(platform_file); } { /* Application deployment */ MSG_function_register("master", master); MSG_function_register("slave", slave); MSG_launch_application(application_file); } res = MSG_main(); XBT_INFO("Simulation time %g", MSG_get_clock()); if (res == MSG_OK) return 0; else return 1; } /* end_of_main */ SimGrid-3.11/teshsuite/msg/process_join/process_join.tesh000644 001750 001750 00000002152 12342443664 022716 0ustar00cici000000 000000 $ ./process_join$EXEEXT ${srcdir:=.}/process_join_p.xml ${srcdir:=.}/process_join_d.xml > [Tremblay:master:(1) 0.000000] [msg_test/INFO] Start slave > [Tremblay:slave from master:(2) 0.000000] [msg_test/INFO] Slave started > [Tremblay:master:(1) 0.000000] [msg_test/INFO] Join the slave (timeout 2) > [Tremblay:master:(1) 2.000000] [msg_test/INFO] Start slave > [Tremblay:slave from master:(3) 2.000000] [msg_test/INFO] Slave started > [Tremblay:master:(1) 2.000000] [msg_test/INFO] Join the slave (timeout 4) > [Tremblay:slave from master:(2) 3.000000] [msg_test/INFO] I'm done. See you! > [Tremblay:slave from master:(3) 5.000000] [msg_test/INFO] I'm done. See you! > [Tremblay:master:(1) 5.000000] [msg_test/INFO] Start slave > [Tremblay:slave from master:(4) 5.000000] [msg_test/INFO] Slave started > [Tremblay:master:(1) 5.000000] [msg_test/INFO] Join the slave (timeout 2) > [Tremblay:master:(1) 7.000000] [msg_test/INFO] Goodbye now! > [Tremblay:slave from master:(4) 8.000000] [msg_test/INFO] I'm done. See you! > [Tremblay:master:(1) 8.000000] [msg_test/INFO] Goodbye now! > [8.000000] [msg_test/INFO] Simulation time 8 SimGrid-3.11/teshsuite/msg/process_join/process_join_d.xml000644 001750 001750 00000000360 12342443670 023052 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/msg/process_join/CMakeLists.txt000644 001750 001750 00000001306 12342443654 022073 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(process_join ${CMAKE_HOME_DIRECTORY}/teshsuite/msg/process_join/process_join.c) ### Add definitions for compile target_link_libraries(process_join simgrid) set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/process_join.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/process_join_d.xml ${CMAKE_CURRENT_SOURCE_DIR}/process_join_p.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/process_join.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/msg/CMakeLists.txt000644 001750 001750 00000000573 12342443654 017403 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") ### Add definitions for compile set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/xbt/000755 001750 001750 00000000000 12342443654 014645 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/xbt/parmap_test/000755 001750 001750 00000000000 12342443665 017166 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/xbt/parmap_test/parmap_test.c000644 001750 001750 00000006762 12342443665 021664 0ustar00cici000000 000000 /* parmap_test -- test parmap */ /* Copyright (c) 2007-2010, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "simgrid/simix.h" #include "xbt.h" #include "xbt/ex.h" #include "xbt/xbt_os_time.h" #include "internal_config.h" XBT_LOG_NEW_DEFAULT_CATEGORY(parmap_test, "Test for parmap"); static void fun_double(void *arg) { unsigned *u = arg; *u = 2 * *u + 1; } static int test_parmap_basic(e_xbt_parmap_mode_t mode) { int ret = 0; unsigned num_workers; for (num_workers = 1 ; num_workers <= 16 ; num_workers *= 2) { const unsigned len = 1033; const unsigned num = 5; unsigned *a; xbt_dynar_t data; xbt_parmap_t parmap; unsigned i; parmap = xbt_parmap_new(num_workers, mode); a = xbt_malloc(len * sizeof *a); data = xbt_dynar_new(sizeof a, NULL); for (i = 0; i < len; i++) { a[i] = i; xbt_dynar_push_as(data, void *, &a[i]); } for (i = 0; i < num; i++) xbt_parmap_apply(parmap, fun_double, data); for (i = 0; i < len; i++) { unsigned expected = (1U << num) * (i + 1) - 1; if (a[i] != expected) { XBT_CRITICAL("with %u threads, a[%u]: expected %u, got %u", num_workers, i, expected, a[i]); ret = 1; break; } } xbt_dynar_free(&data); xbt_free(a); xbt_parmap_destroy(parmap); } return ret; } static void fun_get_id(void *arg) { *(uintptr_t *)arg = (uintptr_t)xbt_os_thread_self(); xbt_os_sleep(0.05); } static int fun_compare(const void *pa, const void *pb) { uintptr_t a = *(uintptr_t *)pa; uintptr_t b = *(uintptr_t *)pb; return a < b ? -1 : a > b ? 1 : 0; } static int test_parmap_extended(e_xbt_parmap_mode_t mode) { int ret = 0; unsigned num_workers; for (num_workers = 1 ; num_workers <= 16 ; num_workers *= 2) { const unsigned len = 2 * num_workers; uintptr_t *a; xbt_parmap_t parmap; xbt_dynar_t data; unsigned i; unsigned count; parmap = xbt_parmap_new(num_workers, mode); a = xbt_malloc(len * sizeof *a); data = xbt_dynar_new(sizeof a, NULL); for (i = 0; i < len; i++) xbt_dynar_push_as(data, void *, &a[i]); xbt_parmap_apply(parmap, fun_get_id, data); qsort(a, len, sizeof a[0], fun_compare); count = 1; for (i = 1; i < len; i++) if (a[i] != a[i - 1]) count++; if (count != num_workers) { XBT_CRITICAL("only %u/%u threads did some work", count, num_workers); ret = 1; } xbt_dynar_free(&data); xbt_free(a); xbt_parmap_destroy(parmap); } return ret; } int main(int argc, char** argv) { int status = 0; SIMIX_global_init(&argc, argv); XBT_INFO("Basic testing posix"); status += test_parmap_basic(XBT_PARMAP_POSIX); XBT_INFO("Basic testing futex"); #ifdef HAVE_FUTEX_H status += test_parmap_basic(XBT_PARMAP_FUTEX); #endif XBT_INFO("Basic testing busy wait"); status += test_parmap_basic(XBT_PARMAP_BUSY_WAIT); XBT_INFO("Extended testing posix"); status += test_parmap_extended(XBT_PARMAP_POSIX); XBT_INFO("Extended testing futex"); #ifdef HAVE_FUTEX_H status += test_parmap_extended(XBT_PARMAP_FUTEX); #endif XBT_INFO("Extended testing busy wait"); status += test_parmap_extended(XBT_PARMAP_BUSY_WAIT); return status == 0 ? EXIT_SUCCESS : EXIT_FAILURE; } SimGrid-3.11/teshsuite/xbt/parmap_test/parmap_test.tesh000644 001750 001750 00000000322 12342443665 022367 0ustar00cici000000 000000 ! timeout 120 $ ${bindir:=.}/parmap_test --log=root.fmt:%m%n > Basic testing posix > Basic testing futex > Basic testing busy wait > Extended testing posix > Extended testing futex > Extended testing busy wait SimGrid-3.11/teshsuite/xbt/parmap_test/CMakeLists.txt000644 001750 001750 00000001054 12342443654 021724 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(parmap_test parmap_test.c) ### Add definitions for compile target_link_libraries(parmap_test simgrid) set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/parmap_test.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/parmap_test.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/xbt/mmalloc/000755 001750 001750 00000000000 12342443665 016273 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/xbt/mmalloc/mmalloc_64.tesh000644 001750 001750 00000010745 12342443665 021124 0ustar00cici000000 000000 $ ${bindir:=.}/mmalloc_test --log=root.fmt:%m%n > Allocating a new heap > HeapA allocated > 100 bytes allocated with offset 39000 > 200 bytes allocated with offset 39100 > 300 bytes allocated with offset 3a000 > 400 bytes allocated with offset 3a200 > 500 bytes allocated with offset 3a400 > 600 bytes allocated with offset 3b000 > 700 bytes allocated with offset 3b400 > 800 bytes allocated with offset 3b800 > 900 bytes allocated with offset 3bc00 > 1000 bytes allocated with offset 3c000 > 1100 bytes allocated with offset 3d000 > 1200 bytes allocated with offset 3d800 > 1300 bytes allocated with offset 3e000 > 1400 bytes allocated with offset 3e800 > 1500 bytes allocated with offset 3f000 > 1600 bytes allocated with offset 3f800 > 1700 bytes allocated with offset 40000 > 1800 bytes allocated with offset 40800 > 1900 bytes allocated with offset 41000 > 2000 bytes allocated with offset 41800 > 2100 bytes allocated with offset 42000 > 2200 bytes allocated with offset 43000 > 2300 bytes allocated with offset 44000 > 2400 bytes allocated with offset 45000 > 2500 bytes allocated with offset 46000 > 2600 bytes allocated with offset 47000 > 2700 bytes allocated with offset 48000 > 2800 bytes allocated with offset 49000 > 2900 bytes allocated with offset 4a000 > 3000 bytes allocated with offset 4b000 > 3100 bytes allocated with offset 4c000 > 3200 bytes allocated with offset 4d000 > 3300 bytes allocated with offset 4e000 > 3400 bytes allocated with offset 4f000 > 3500 bytes allocated with offset 50000 > 3600 bytes allocated with offset 51000 > 3700 bytes allocated with offset 52000 > 3800 bytes allocated with offset 53000 > 3900 bytes allocated with offset 54000 > 4000 bytes allocated with offset 55000 > 4100 bytes allocated with offset 56000 > 4200 bytes allocated with offset 58000 > 4300 bytes allocated with offset 5a000 > 4400 bytes allocated with offset 5c000 > 4500 bytes allocated with offset 5e000 > 4600 bytes allocated with offset 60000 > 4700 bytes allocated with offset 62000 > 4800 bytes allocated with offset 64000 > 4900 bytes allocated with offset 66000 > 5000 bytes allocated with offset 68000 > 100 bytes allocated with offset 39200 > 200 bytes allocated with offset 39300 > 300 bytes allocated with offset 3a600 > 400 bytes allocated with offset 3a800 > 500 bytes allocated with offset 3aa00 > 600 bytes allocated with offset 3c400 > 700 bytes allocated with offset 3c800 > 800 bytes allocated with offset 3cc00 > 900 bytes allocated with offset 6a000 > 1000 bytes allocated with offset 6a400 > 1100 bytes allocated with offset 6b000 > 1200 bytes allocated with offset 6b800 > 1300 bytes allocated with offset 6c000 > 1400 bytes allocated with offset 6c800 > 1500 bytes allocated with offset 6d000 > 1600 bytes allocated with offset 6d800 > 1700 bytes allocated with offset 6e000 > 1800 bytes allocated with offset 6e800 > 1900 bytes allocated with offset 6f000 > 2000 bytes allocated with offset 6f800 > 2100 bytes allocated with offset 70000 > 2200 bytes allocated with offset 71000 > 2300 bytes allocated with offset 72000 > 2400 bytes allocated with offset 73000 > 2500 bytes allocated with offset 74000 > 2600 bytes allocated with offset 75000 > 2700 bytes allocated with offset 76000 > 2800 bytes allocated with offset 77000 > 2900 bytes allocated with offset 78000 > 3000 bytes allocated with offset 79000 > 3100 bytes allocated with offset 7a000 > 3200 bytes allocated with offset 7b000 > 3300 bytes allocated with offset 7c000 > 3400 bytes allocated with offset 7d000 > 3500 bytes allocated with offset 7e000 > 3600 bytes allocated with offset 7f000 > 3700 bytes allocated with offset 80000 > 3800 bytes allocated with offset 81000 > 3900 bytes allocated with offset 82000 > 4000 bytes allocated with offset 83000 > 4100 bytes allocated with offset 84000 > 4200 bytes allocated with offset 86000 > 4300 bytes allocated with offset 88000 > 4400 bytes allocated with offset 8a000 > 4500 bytes allocated with offset 8c000 > 4600 bytes allocated with offset 8e000 > 4700 bytes allocated with offset 90000 > 4800 bytes allocated with offset 92000 > 4900 bytes allocated with offset 94000 > 5000 bytes allocated with offset 96000 > All blocks were correctly allocated. Free every second block > Memset every second block to zero (yeah, they are not currently allocated :) > Re-allocate every second block > free all blocks (each one twice, to check that double free are correctly catched) > free again all blocks (to really check that double free are correctly catched) > Damnit, I cannot break mmalloc this time. That's SO disappointing. SimGrid-3.11/teshsuite/xbt/mmalloc/mmalloc_test.c000644 001750 001750 00000005113 12342443665 021122 0ustar00cici000000 000000 /* Copyright (c) 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "xbt/mmalloc.h" #include "xbt.h" #include #include #include #include #include #include #include XBT_LOG_NEW_DEFAULT_CATEGORY(test,"this test"); #define BUFFSIZE 204800 #define TESTSIZE 100 #define size_of_block(i) (((i % 50)+1)* 100) int main(int argc, char**argv) { void *heapA; void *pointers[TESTSIZE]; xbt_init(&argc,argv); XBT_INFO("Allocating a new heap"); unsigned long mask = ~((unsigned long)xbt_pagesize - 1); void *addr = (void*)(((unsigned long)sbrk(0) + BUFFSIZE) & mask); heapA = xbt_mheap_new(-1, addr); if (heapA == NULL) { perror("attach 1 failed"); fprintf(stderr, "bye\n"); exit(1); } XBT_INFO("HeapA allocated"); int i, size; for (i = 0; i < TESTSIZE; i++) { size = size_of_block(i); pointers[i] = mmalloc(heapA, size); XBT_INFO("%d bytes allocated with offset %tx", size, ((char*)pointers[i])-((char*)heapA)); } XBT_INFO("All blocks were correctly allocated. Free every second block"); for (i = 0; i < TESTSIZE; i+=2) { mfree(heapA,pointers[i]); } XBT_INFO("Memset every second block to zero (yeah, they are not currently allocated :)"); for (i = 0; i < TESTSIZE; i+=2) { size = size_of_block(i); memset(pointers[i],0, size); } XBT_INFO("Re-allocate every second block"); for (i = 0; i < TESTSIZE; i+=2) { size = size_of_block(i); pointers[i] = mmalloc(heapA, size); } XBT_INFO("free all blocks (each one twice, to check that double free are correctly catched)"); for (i = 0; i < TESTSIZE; i++) { xbt_ex_t e; int gotit = 1; mfree(heapA, pointers[i]); TRY { mfree(heapA, pointers[i]); gotit = 0; } CATCH(e) { xbt_ex_free(e); } if (!gotit) xbt_die("FAIL: A double-free went undetected (for size:%d)",size_of_block(i)); } XBT_INFO("free again all blocks (to really check that double free are correctly catched)"); for (i = 0; i < TESTSIZE; i++) { xbt_ex_t e; int gotit = 1; TRY { mfree(heapA, pointers[i]); gotit = 0; } CATCH(e) { xbt_ex_free(e); } if (!gotit) xbt_die("FAIL: A double-free went undetected (for size:%d)",size_of_block(i)); } XBT_INFO("Damnit, I cannot break mmalloc this time. That's SO disappointing."); return 0; } SimGrid-3.11/teshsuite/xbt/mmalloc/mmalloc_32.tesh000644 001750 001750 00000010745 12342443665 021117 0ustar00cici000000 000000 $ ${bindir:=.}/mmalloc_test --log=root.fmt:%m%n > Allocating a new heap > HeapA allocated > 100 bytes allocated with offset 45000 > 200 bytes allocated with offset 46000 > 300 bytes allocated with offset 47000 > 400 bytes allocated with offset 47200 > 500 bytes allocated with offset 47400 > 600 bytes allocated with offset 48000 > 700 bytes allocated with offset 48400 > 800 bytes allocated with offset 48800 > 900 bytes allocated with offset 48c00 > 1000 bytes allocated with offset 49000 > 1100 bytes allocated with offset 4a000 > 1200 bytes allocated with offset 4a800 > 1300 bytes allocated with offset 4b000 > 1400 bytes allocated with offset 4b800 > 1500 bytes allocated with offset 4c000 > 1600 bytes allocated with offset 4c800 > 1700 bytes allocated with offset 4d000 > 1800 bytes allocated with offset 4d800 > 1900 bytes allocated with offset 4e000 > 2000 bytes allocated with offset 4e800 > 2100 bytes allocated with offset 4f000 > 2200 bytes allocated with offset 50000 > 2300 bytes allocated with offset 51000 > 2400 bytes allocated with offset 52000 > 2500 bytes allocated with offset 53000 > 2600 bytes allocated with offset 54000 > 2700 bytes allocated with offset 55000 > 2800 bytes allocated with offset 56000 > 2900 bytes allocated with offset 57000 > 3000 bytes allocated with offset 58000 > 3100 bytes allocated with offset 59000 > 3200 bytes allocated with offset 5a000 > 3300 bytes allocated with offset 5b000 > 3400 bytes allocated with offset 5c000 > 3500 bytes allocated with offset 5d000 > 3600 bytes allocated with offset 5e000 > 3700 bytes allocated with offset 5f000 > 3800 bytes allocated with offset 60000 > 3900 bytes allocated with offset 61000 > 4000 bytes allocated with offset 62000 > 4100 bytes allocated with offset 63000 > 4200 bytes allocated with offset 65000 > 4300 bytes allocated with offset 67000 > 4400 bytes allocated with offset 69000 > 4500 bytes allocated with offset 6b000 > 4600 bytes allocated with offset 6d000 > 4700 bytes allocated with offset 6f000 > 4800 bytes allocated with offset 71000 > 4900 bytes allocated with offset 73000 > 5000 bytes allocated with offset 75000 > 100 bytes allocated with offset 45080 > 200 bytes allocated with offset 46100 > 300 bytes allocated with offset 47600 > 400 bytes allocated with offset 47800 > 500 bytes allocated with offset 47a00 > 600 bytes allocated with offset 49400 > 700 bytes allocated with offset 49800 > 800 bytes allocated with offset 49c00 > 900 bytes allocated with offset 77000 > 1000 bytes allocated with offset 77400 > 1100 bytes allocated with offset 78000 > 1200 bytes allocated with offset 78800 > 1300 bytes allocated with offset 79000 > 1400 bytes allocated with offset 79800 > 1500 bytes allocated with offset 7a000 > 1600 bytes allocated with offset 7a800 > 1700 bytes allocated with offset 7b000 > 1800 bytes allocated with offset 7b800 > 1900 bytes allocated with offset 7c000 > 2000 bytes allocated with offset 7c800 > 2100 bytes allocated with offset 7d000 > 2200 bytes allocated with offset 7e000 > 2300 bytes allocated with offset 7f000 > 2400 bytes allocated with offset 80000 > 2500 bytes allocated with offset 81000 > 2600 bytes allocated with offset 82000 > 2700 bytes allocated with offset 83000 > 2800 bytes allocated with offset 84000 > 2900 bytes allocated with offset 85000 > 3000 bytes allocated with offset 86000 > 3100 bytes allocated with offset 87000 > 3200 bytes allocated with offset 88000 > 3300 bytes allocated with offset 89000 > 3400 bytes allocated with offset 8a000 > 3500 bytes allocated with offset 8b000 > 3600 bytes allocated with offset 8c000 > 3700 bytes allocated with offset 8d000 > 3800 bytes allocated with offset 8e000 > 3900 bytes allocated with offset 8f000 > 4000 bytes allocated with offset 90000 > 4100 bytes allocated with offset 91000 > 4200 bytes allocated with offset 93000 > 4300 bytes allocated with offset 95000 > 4400 bytes allocated with offset 97000 > 4500 bytes allocated with offset 99000 > 4600 bytes allocated with offset 9b000 > 4700 bytes allocated with offset 9d000 > 4800 bytes allocated with offset 9f000 > 4900 bytes allocated with offset a1000 > 5000 bytes allocated with offset a3000 > All blocks were correctly allocated. Free every second block > Memset every second block to zero (yeah, they are not currently allocated :) > Re-allocate every second block > free all blocks (each one twice, to check that double free are correctly catched) > free again all blocks (to really check that double free are correctly catched) > Damnit, I cannot break mmalloc this time. That's SO disappointing. SimGrid-3.11/teshsuite/xbt/mmalloc/CMakeLists.txt000644 001750 001750 00000001131 12342443654 021025 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") if(HAVE_MMALLOC) add_executable(mmalloc_test mmalloc_test.c) target_link_libraries(mmalloc_test simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/mmalloc_64.tesh ${CMAKE_CURRENT_SOURCE_DIR}/mmalloc_32.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/mmalloc_test.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/xbt/heap_bench/000755 001750 001750 00000000000 12342443666 016724 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/xbt/heap_bench/heap_bench.c000644 001750 001750 00000005523 12342443666 021151 0ustar00cici000000 000000 /* A few tests for the xbt_heap module */ /* Copyright (c) 2004-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifdef __BORLANDC__ #pragma hdrstop #endif #include #include #include #include "xbt/heap.h" #include "xbt/sysdep.h" /* calloc, printf */ #define MAX_TEST 1000000 #ifdef __BORLANDC__ int _XBT_CALL compare_double(const void *a, const void *b); #else int compare_double(const void *a, const void *b); #endif void test_heap_validity(int size); void test_heap_mean_operation(int size); void test_reset_heap(xbt_heap_t * heap, int size); int compare_double(const void *a, const void *b) { double pa, pb; pa = *((double *) a); pb = *((double *) b); if (pa > pb) return 1; if (pa == pb) return 0; return -1; } void test_heap_validity(int size) { xbt_heap_t heap = xbt_heap_new(size, NULL); double *tab = xbt_new0(double, size); int i; for (i = 0; i < size; i++) { tab[i] = (double) (10.0 * rand() / (RAND_MAX + 1.0)); xbt_heap_push(heap, NULL, (double) tab[i]); } qsort(tab, size, sizeof(double), compare_double); for (i = 0; i < size; i++) { /* printf("%g" " ", xbt_heap_maxkey(heap)); */ if (xbt_heap_maxkey(heap) != tab[i]) { fprintf(stderr, "Problem !\n"); exit(1); } xbt_heap_pop(heap); } xbt_heap_free(heap); free(tab); printf("Validity test complete!\n"); } void test_heap_mean_operation(int size) { xbt_heap_t heap = xbt_heap_new(size, NULL); double val; double date = 0; int i, j; date = xbt_os_time() * 1000000; for (i = 0; i < size; i++) xbt_heap_push(heap, NULL, (10.0 * rand() / (RAND_MAX + 1.0))); date = xbt_os_time() * 1000000 - date; printf("Creation time %d size heap : %g\n", size, date); date = xbt_os_time() * 1000000; for (j = 0; j < MAX_TEST; j++) { if (!(j % size) && j) test_reset_heap(&heap, size); val = xbt_heap_maxkey(heap); xbt_heap_pop(heap); xbt_heap_push(heap, NULL, 3.0 * val); } date = xbt_os_time() * 1000000 - date; printf("Mean access time for a %d size heap : %g\n", size, date * 1.0 / (MAX_TEST + 0.0)); xbt_heap_free(heap); } void test_reset_heap(xbt_heap_t * heap, int size) { int i; xbt_heap_free(*heap); *heap = xbt_heap_new(size, NULL); for (i = 0; i < size; i++) { xbt_heap_push(*heap, NULL, (10.0 * rand() / (RAND_MAX + 1.0))); } } #ifdef __BORLANDC__ #pragma argsused #endif int main(int argc, char **argv) { int size; for (size = 100; size < 10000; size *= 10) { test_heap_validity(size); test_heap_mean_operation(size); } return 0; } SimGrid-3.11/teshsuite/xbt/heap_bench/heap_bench.tesh000644 001750 001750 00000000445 12342443665 021667 0ustar00cici000000 000000 #! ./tesh ! output display $ $SG_TEST_EXENV ${bindir:=.}/heap_bench > Validity test complete! > Creation time 100 size heap : 6 > Mean access time for a 100 size heap : 0.14687 > Validity test complete! > Creation time 1000 size heap : 38 > Mean access time for a 1000 size heap : 0.179765 SimGrid-3.11/teshsuite/xbt/heap_bench/CMakeLists.txt000644 001750 001750 00000001247 12342443654 021465 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(heap_bench ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/heap_bench/heap_bench.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(heap_bench simgrid m ) else() target_link_libraries(heap_bench simgrid ) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/heap_bench.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(testsuite_src ${testsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/heap_bench.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/xbt/log_large/000755 001750 001750 00000000000 12342443665 016602 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/xbt/log_large/log_large_test.tesh000644 001750 001750 00000051412 12342443665 022464 0ustar00cici000000 000000 p Check that the dynamic version of the log simple layout works $ $SG_EXENV_TEST ${bindir:=.}/log_large_test "--log=root.fmt:%m%n" > This is a very large message: > 0 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 1 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > > Done (strlen>10210) p Check that the dynamic version of the log formated layout works $ $SG_EXENV_TEST ${bindir:=.}/log_large_test "--log=root.fmt:%m%n" > This is a very large message: > 0 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 1 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9 > 1.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 2.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 3.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 4.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 5.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 6.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 7.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 8.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 9.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > 0.........1.........2.........3.........4.........5.........6.........7.........8.........9.........0 > > Done (strlen>10210) SimGrid-3.11/teshsuite/xbt/log_large/log_large_test.c000644 001750 001750 00000004424 12342443665 021744 0ustar00cici000000 000000 /* log_large_test -- log a very large string to test the dynamic variants */ /* Copyright (c) 2007-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "xbt.h" XBT_LOG_NEW_DEFAULT_CATEGORY(test, "Logs of this example"); int main(int argc, char *argv[]) { char *tmp = bprintf("\n%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s%d%s", 1, ".........1.........2.........3.........4.........5.........6.........7.........8.........9.........0\n", 2, ".........1.........2.........3.........4.........5.........6.........7.........8.........9.........0\n", 3, ".........1.........2.........3.........4.........5.........6.........7.........8.........9.........0\n", 4, ".........1.........2.........3.........4.........5.........6.........7.........8.........9.........0\n", 5, ".........1.........2.........3.........4.........5.........6.........7.........8.........9.........0\n", 6, ".........1.........2.........3.........4.........5.........6.........7.........8.........9.........0\n", 7, ".........1.........2.........3.........4.........5.........6.........7.........8.........9.........0\n", 8, ".........1.........2.........3.........4.........5.........6.........7.........8.........9.........0\n", 9, ".........1.........2.........3.........4.........5.........6.........7.........8.........9.........0\n", 0, ".........1.........2.........3.........4.........5.........6.........7.........8.........9.........0\n"); xbt_init(&argc, argv); XBT_INFO("This is a very large message:\n0%s1%s2%s3%s4%s5%s6%s7%s8%s9%s", tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp); XBT_INFO("Done (strlen>%d)", (int) (10 * strlen(tmp))); free(tmp); return 0; } SimGrid-3.11/teshsuite/xbt/log_large/CMakeLists.txt000644 001750 001750 00000001073 12342443654 021341 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(log_large_test log_large_test.c) ### Add definitions for compile target_link_libraries(log_large_test simgrid) set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/log_large_test.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/log_large_test.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/xbt/parmap_bench/000755 001750 001750 00000000000 12342443666 017267 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/xbt/parmap_bench/parmap_bench.c000644 001750 001750 00000012021 12342443666 022046 0ustar00cici000000 000000 /* Copyright (c) 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include #include #include #include /* HAVE_FUTEX_H */ #include "simgrid/simix.h" #include "xbt/xbt_os_time.h" #define MODES_DEFAULT 0x7 #define TIMEOUT 10.0 #define ARRAY_SIZE 10007 #define FIBO_MAX 25 void (*fun_to_apply)(void *); static const char *parmap_mode_name(e_xbt_parmap_mode_t mode) { static char name[80]; switch (mode) { case XBT_PARMAP_POSIX: snprintf(name, sizeof name, "POSIX"); break; case XBT_PARMAP_FUTEX: snprintf(name, sizeof name, "FUTEX"); break; case XBT_PARMAP_BUSY_WAIT: snprintf(name, sizeof name, "BUSY_WAIT"); break; case XBT_PARMAP_DEFAULT: snprintf(name, sizeof name, "DEFAULT"); break; default: snprintf(name, sizeof name, "UNKNOWN(%d)", (int)mode); break; } return name; } static int parmap_skip_mode(e_xbt_parmap_mode_t mode) { switch (mode) { #ifndef HAVE_FUTEX_H case XBT_PARMAP_FUTEX: printf("not available\n"); return 1; #endif default: return 0; } } static unsigned fibonacci(unsigned n) { if (n < 2) return n; else return fibonacci(n - 1) + fibonacci(n - 2); } static void fun_small_comp(void *arg) { unsigned *u = arg; *u = 2 * *u + 1; } static void fun_big_comp(void *arg) { unsigned *u = arg; *u = fibonacci(*u % FIBO_MAX); } static void array_new(unsigned **a, xbt_dynar_t *data) { int i; *a = xbt_malloc(ARRAY_SIZE * sizeof **a); *data = xbt_dynar_new(sizeof *a, NULL); xbt_dynar_shrink(*data, ARRAY_SIZE); for (i = 0 ; i < ARRAY_SIZE ; i++) { (*a)[i] = i; xbt_dynar_push_as(*data, void*, &(*a)[i]); } } static void bench_parmap_full(int nthreads, e_xbt_parmap_mode_t mode) { unsigned *a; xbt_dynar_t data; xbt_parmap_t parmap; int i; double start_time, elapsed_time; printf("** mode = %-15s ", parmap_mode_name(mode)); fflush(stdout); if (parmap_skip_mode(mode)) return; array_new(&a, &data); i = 0; start_time = xbt_os_time(); do { parmap = xbt_parmap_new(nthreads, mode); xbt_parmap_apply(parmap, fun_to_apply, data); xbt_parmap_destroy(parmap); elapsed_time = xbt_os_time() - start_time; i++; } while (elapsed_time < TIMEOUT); printf("ran %d times in %g seconds (%g/s)\n", i, elapsed_time, i / elapsed_time); xbt_dynar_free(&data); xbt_free(a); } static void bench_parmap_apply(int nthreads, e_xbt_parmap_mode_t mode) { unsigned *a; xbt_dynar_t data; xbt_parmap_t parmap; int i; double start_time, elapsed_time; printf("** mode = %-15s ", parmap_mode_name(mode)); fflush(stdout); if (parmap_skip_mode(mode)) return; array_new(&a, &data); parmap = xbt_parmap_new(nthreads, mode); i = 0; start_time = xbt_os_time(); do { xbt_parmap_apply(parmap, fun_to_apply, data); elapsed_time = xbt_os_time() - start_time; i++; } while (elapsed_time < TIMEOUT); xbt_parmap_destroy(parmap); printf("ran %d times in %g seconds (%g/s)\n", i, elapsed_time, i / elapsed_time); xbt_dynar_free(&data); xbt_free(a); } static void bench_all_modes(void (*bench_fun)(int, e_xbt_parmap_mode_t), int nthreads, unsigned modes) { e_xbt_parmap_mode_t all_modes[] = { XBT_PARMAP_POSIX, XBT_PARMAP_FUTEX, XBT_PARMAP_BUSY_WAIT, XBT_PARMAP_DEFAULT }; unsigned i; for (i = 0 ; i < sizeof all_modes / sizeof all_modes[0] ; i++) { if (1U << i & modes) bench_fun(nthreads, all_modes[i]); } } int main(int argc, char *argv[]) { int nthreads; unsigned modes = MODES_DEFAULT; SIMIX_global_init(&argc, argv); if (argc != 2 && argc != 3) { fprintf(stderr, "Usage: %s nthreads [modes]\n" " nthreads - number of working threads\n" " modes - bitmask of modes to test\n", argv[0]); return EXIT_FAILURE; } nthreads = atoi(argv[1]); if (nthreads < 1) { fprintf(stderr, "ERROR: invalid thread count: %d\n", nthreads); return EXIT_FAILURE; } if (argc == 3) modes = strtol(argv[2], NULL, 0); printf("Parmap benchmark with %d workers (modes = %#x)...\n\n", nthreads, modes); fun_to_apply = fun_small_comp; printf("Benchmark for parmap create+apply+destroy (small comp):\n"); bench_all_modes(bench_parmap_full, nthreads, modes); printf("\n"); printf("Benchmark for parmap apply only (small comp):\n"); bench_all_modes(bench_parmap_apply, nthreads, modes); printf("\n"); fun_to_apply = fun_big_comp; printf("Benchmark for parmap create+apply+destroy (big comp):\n"); bench_all_modes(bench_parmap_full, nthreads, modes); printf("\n"); printf("Benchmark for parmap apply only (big comp):\n"); bench_all_modes(bench_parmap_apply, nthreads, modes); printf("\n"); return EXIT_SUCCESS; } SimGrid-3.11/teshsuite/xbt/parmap_bench/parmap_bench.tesh000644 001750 001750 00000000070 12342443665 022567 0ustar00cici000000 000000 #! ./tesh $ $SG_TEST_EXENV ${bindir:=.}/parmap_bench > SimGrid-3.11/teshsuite/xbt/parmap_bench/CMakeLists.txt000644 001750 001750 00000001265 12342443654 022030 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(parmap_bench ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/parmap_bench/parmap_bench.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(parmap_bench simgrid m ) else() target_link_libraries(parmap_bench simgrid ) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/parmap_bench.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(testsuite_src ${testsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/parmap_bench.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/xbt/graphxml_usage/000755 001750 001750 00000000000 12342443670 017651 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/xbt/graphxml_usage/graphxml_usage.tesh000644 001750 001750 00000003137 12342443665 023554 0ustar00cici000000 000000 #! ./tesh $ $SG_TEST_EXENV ${bindir:=.}/graphxml_usage graph.xml > [0.000000] [test/INFO] ---- Testing XML export. Exporting to testgraph.xml ---- > [0.000000] [test/INFO] ---- Testing GraphViz export. Exporting to testgraph.dot ---- > [0.000000] [test/INFO] ---- Dumping Edge lengths ---- > [0.000000] [test/INFO] 0.000 0.410 -1.000 -1.000 -1.000 -1.000 -1.000 -1.000 > [0.000000] [test/INFO] -1.000 0.000 0.510 -1.000 -1.000 -1.000 -1.000 -1.000 > [0.000000] [test/INFO] -1.000 -1.000 0.000 0.500 -1.000 -1.000 -1.000 -1.000 > [0.000000] [test/INFO] -1.000 -1.000 -1.000 0.000 -1.000 0.380 -1.000 -1.000 > [0.000000] [test/INFO] -1.000 -1.000 -1.000 0.360 0.000 -1.000 -1.000 -1.000 > [0.000000] [test/INFO] -1.000 -1.000 -1.000 -1.000 -1.000 0.000 -1.000 -1.000 > [0.000000] [test/INFO] -1.000 -1.000 -1.000 -1.000 0.380 -1.000 0.000 -1.000 > [0.000000] [test/INFO] -1.000 -1.000 -1.000 -1.000 -1.000 -1.000 -1.000 0.000 > [0.000000] [test/INFO] ---- Testing Shortest Paths ---- > [0.000000] [test/INFO] A B B B B > [0.000000] [test/INFO] B C C C > [0.000000] [test/INFO] C D D > [0.000000] [test/INFO] D F > [0.000000] [test/INFO] D E D > [0.000000] [test/INFO] F > [0.000000] [test/INFO] E E E M > [0.000000] [test/INFO] P > [0.000000] [test/INFO] ---- Testing Topological Sort ---- > [0.000000] [test/INFO] sorted[0] = P > [0.000000] [test/INFO] sorted[1] = M > [0.000000] [test/INFO] sorted[2] = E > [0.000000] [test/INFO] sorted[3] = A > [0.000000] [test/INFO] sorted[4] = B > [0.000000] [test/INFO] sorted[5] = C > [0.000000] [test/INFO] sorted[6] = D > [0.000000] [test/INFO] sorted[7] = F SimGrid-3.11/teshsuite/xbt/graphxml_usage/graphxml_usage.c000644 001750 001750 00000010674 12342443666 023040 0ustar00cici000000 000000 /* A few basic tests for the graphxml library */ /* Copyright (c) 2006-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifdef __BORLANDC__ #pragma hdrstop #endif #include #ifdef _MSC_VER #define snprintf _snprintf #endif #include "xbt/module.h" #include "xbt/sysdep.h" #include "xbt/graph.h" #include "xbt/graphxml.h" #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_CATEGORY(test, "Logging specific to graphxml test"); static void *node_label_and_data(xbt_node_t node, const char *label, const char *data) { char *lbl = xbt_strdup(label); return lbl; } #define free_label free static const char *node_name(xbt_node_t n) { return xbt_graph_node_get_data(n); } void test(char *graph_file); void test(char *graph_file) { int test_node_deletion = 0; int test_edge_deletion = 0; int test_export_xml = 1; int test_export_dot = 1; int test_export_length = 1; int test_shortest_paths = 1; int test_topo_sort = 1; unsigned long i, j; unsigned long n; xbt_dynar_t edges = NULL; xbt_dynar_t nodes = NULL; xbt_graph_t graph = xbt_graph_read(graph_file, &node_label_and_data, NULL); n = xbt_dynar_length(xbt_graph_get_nodes(graph)); if (test_export_xml) { XBT_INFO("---- Testing XML export. Exporting to testgraph.xml ----"); xbt_graph_export_graphxml(graph, "testgraph.xml", NULL, NULL, NULL, NULL); } if (test_export_dot) { XBT_INFO("---- Testing GraphViz export. Exporting to testgraph.dot ----"); xbt_graph_export_graphviz(graph, "testgraph.dot", node_name, NULL); } if (test_export_length) { char *buf = NULL; double *adj = NULL; XBT_INFO("---- Dumping Edge lengths ----"); adj = xbt_graph_get_length_matrix(graph); buf = xbt_new0(char, n * 20); for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { sprintf(buf + strlen(buf), "%6.3f\t", adj[i * n + j]); } XBT_INFO("%s", buf); buf[0] = '\000'; } free(buf); free(adj); } if (test_shortest_paths) { char *buf = NULL; xbt_node_t *route = NULL; XBT_INFO("---- Testing Shortest Paths ----"); route = xbt_graph_shortest_paths(graph); buf = xbt_new0(char, n * 40); for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { if (route[i * n + j]) snprintf(buf + strlen(buf), 40, "%s\t", node_name(route[i * n + j])); } XBT_INFO("%s", buf); buf[0] = '\000'; } free(buf); free(route); } if (test_topo_sort) { xbt_node_t *sorted = NULL; XBT_INFO("---- Testing Topological Sort ----"); sorted = xbt_graph_topo_sort(graph); for (i = 0; i < n; i++) { if (sorted[i]) { XBT_INFO("sorted[%lu] = %s", i, node_name(sorted[i])); } } free(sorted); } if (test_node_deletion) { XBT_INFO("---- Testing Node Deletion ----"); nodes = xbt_graph_get_nodes(graph); edges = xbt_graph_get_edges(graph); XBT_INFO("Before Node deletion: %lu nodes, %lu edges", xbt_dynar_length(nodes), xbt_dynar_length(edges)); while (!xbt_dynar_is_empty(nodes)) xbt_graph_free_node(graph, *((xbt_node_t *) xbt_dynar_get_ptr(nodes, 0)), free_label, NULL); XBT_INFO("After Node deletion: %lu nodes, %lu edges", xbt_dynar_length(nodes), xbt_dynar_length(edges)); } if (test_edge_deletion) { XBT_INFO("---- Testing Edge Deletion ----"); nodes = xbt_graph_get_nodes(graph); edges = xbt_graph_get_edges(graph); XBT_INFO("Before Edge deletion: %lu nodes, %lu edges", xbt_dynar_length(nodes), xbt_dynar_length(edges)); while (!xbt_dynar_is_empty(edges)) xbt_graph_free_edge(graph, *((xbt_edge_t *) xbt_dynar_get_ptr(edges, 0)), NULL); XBT_INFO("After Edge deletion: %lu nodes, %lu edges", xbt_dynar_length(nodes), xbt_dynar_length(edges)); } xbt_graph_free_graph(graph, free_label, NULL, NULL); } #ifdef __BORLANDC__ #pragma argsused #endif int main(int argc, char **argv) { xbt_init(&argc, argv); if (argc == 1) { fprintf(stderr, "Usage : %s graph.xml\n", argv[0]); return 1; } test(argv[1]); return 0; } SimGrid-3.11/teshsuite/xbt/graphxml_usage/graph.xml000644 001750 001750 00000002200 12342443670 021466 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/xbt/graphxml_usage/CMakeLists.txt000644 001750 001750 00000001353 12342443654 022415 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(graphxml_usage ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/graphxml_usage/graphxml_usage.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(graphxml_usage simgrid m ) else() target_link_libraries(graphxml_usage simgrid ) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/graphxml_usage.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/graph.xml PARENT_SCOPE ) set(testsuite_src ${testsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/graphxml_usage.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/xbt/parallel_log/000755 001750 001750 00000000000 12342443665 017304 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/xbt/parallel_log/parallel_log_crashtest.tesh000644 001750 001750 00001236223 12342443665 024717 0ustar00cici000000 000000 ! timeout 20 p Try to crash the log mecanism by using it in parallel with a lot of threads $ ${bindir:=.}/parallel_log_crashtest "--log=root.fmt:%m%n" > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) > XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX) SimGrid-3.11/teshsuite/xbt/parallel_log/parallel_log_crashtest.c000644 001750 001750 00000003702 12342443665 024167 0ustar00cici000000 000000 /* synchro_crashtest -- tries to crash the logging mecanism by doing // logs*/ /* Copyright (c) 2007-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "xbt.h" XBT_LOG_NEW_DEFAULT_CATEGORY(synchro_crashtest, "Logs of this example"); int test_amount = 99; /* Up to 999 to not break the logs (and thus the testing mecanism) */ int crasher_amount = 99; /* Up to 99 to not break the logs (and thus the testing mecanism) */ int *id; /* to pass a pointer to the threads without race condition */ int more_info = 0; /* SET IT TO TRUE TO GET MORE INFO */ /* Code ran by each thread */ static void* crasher_thread(void *arg) { int id = *(int *) arg; int i; for (i = 0; i < test_amount; i++) { if (more_info) XBT_INFO("%03d (%02d|%02d|%02d|%02d|%02d|%02d|%02d|%02d|%02d)", test_amount - i, id, id, id, id, id, id, id, id, id); else XBT_INFO("XXX (XX|XX|XX|XX|XX|XX|XX|XX|XX)"); } return NULL; } int crasher(int argc, char *argv[]); int crasher(int argc, char *argv[]) { int i; xbt_os_thread_t *crashers; xbt_init(&argc, argv); /* initializations of the philosopher mecanisms */ id = xbt_new0(int, crasher_amount); crashers = xbt_new(xbt_os_thread_t, crasher_amount); for (i = 0; i < crasher_amount; i++) id[i] = i; /* spawn threads */ for (i = 0; i < crasher_amount; i++) { char *name = bprintf("thread %d", i); crashers[i] = xbt_os_thread_create(name, &crasher_thread, &id[i], NULL ); free(name); } /* wait for them */ for (i = 0; i < crasher_amount; i++) xbt_os_thread_join(crashers[i],NULL); xbt_free(crashers); xbt_free(id); return 0; } int main(int argc, char *argv[]) { return crasher(argc, argv); } SimGrid-3.11/teshsuite/xbt/parallel_log/CMakeLists.txt000644 001750 001750 00000001143 12342443654 022041 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(parallel_log_crashtest parallel_log_crashtest.c) ### Add definitions for compile target_link_libraries(parallel_log_crashtest simgrid) set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/parallel_log_crashtest.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/parallel_log_crashtest.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/xbt/log_usage/000755 001750 001750 00000000000 12342443666 016615 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/xbt/log_usage/log_usage.tesh000644 001750 001750 00000001526 12342443665 021452 0ustar00cici000000 000000 #! ./tesh $ $SG_TEST_EXENV ${bindir:=.}/log_usage "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] Test with the settings '' > [ 0.000000] [0:@] val=2 > [ 0.000000] [0:@] false alarm! > [ 0.000000] [0:@] Test with the settings ' ' > [ 0.000000] [0:@] val=2 > [ 0.000000] [0:@] false alarm! > [ 0.000000] [0:@] Test with the settings ' test.thres:info root.thres:info ' > [ 0.000000] [0:@] val=2 > [ 0.000000] [0:@] false alarm! > [ 0.000000] [0:@] Test with the settings ' test.thres:debug ' > [ 0.000000] [0:@] val=1 > [ 0.000000] [0:@] val=2 > [ 0.000000] [0:@] false alarm! > [ 0.000000] [0:@] Test with the settings ' test.thres:verbose root.thres:error ' > [ 0.000000] [0:@] val=2 > [ 0.000000] [0:@] false alarm! > [ 0.000000] [0:@] Test with the settings ' test.thres:critical ' > [ 0.000000] [0:@] false alarm! SimGrid-3.11/teshsuite/xbt/log_usage/log_usage.c000644 001750 001750 00000002300 12342443666 020721 0ustar00cici000000 000000 /* log_usage - A test of normal usage of the log facilities */ /* Copyright (c) 2004-2007, 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifdef __BORLANDC__ #pragma hdrstop #endif #include "xbt.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(test, top, "Logging specific to this test"); XBT_LOG_NEW_CATEGORY(top, "Useless test channel"); #ifdef __BORLANDC__ #pragma argsused #endif static void dolog(const char *settings) { XBT_INFO("Test with the settings '%s'", settings); xbt_log_control_set(settings); XBT_DEBUG("val=%d", 1); XBT_WARN("val=%d", 2); XBT_CDEBUG(top, "val=%d%s", 3, "!"); XBT_CRITICAL("false alarm%s%s%s%s%s%s", "", "", "", "", "", "!"); } int main(int argc, char **argv) { xbt_init(&argc, argv); dolog(""); dolog(" "); dolog(" test.thres:info root.thres:info "); #ifndef NDEBUG dolog(" test.thres:debug "); #endif dolog(" test.thres:verbose root.thres:error "); dolog(" test.thres:critical "); return 0; } SimGrid-3.11/teshsuite/xbt/log_usage/CMakeLists.txt000644 001750 001750 00000001240 12342443654 021347 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(log_usage ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/log_usage/log_usage.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(log_usage simgrid m ) else() target_link_libraries(log_usage simgrid ) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/log_usage.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(testsuite_src ${testsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/log_usage.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/bug-17132/000755 001750 001750 00000000000 12342443670 015276 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/bug-17132/bug-17132.tesh000644 001750 001750 00000001504 12342443665 017417 0ustar00cici000000 000000 $ ../../smpi_script/bin/smpirun -np 16 -platform ${srcdir:=.}/small_platform.xml -hostfile ${srcdir:=.}/hostfile.txt ./bug-17132 --cfg=smpi/cpu_threshold:-1 --log=smpi_kernel.thres:warning > You requested to use 16 processes, but there is only 2 processes in your hostfile... > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'smpi/cpu_threshold' to '-1' > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > Walltime = 0.00212779 SimGrid-3.11/teshsuite/bug-17132/hostfile.txt000644 001750 001750 00000000014 12342443666 017654 0ustar00cici000000 000000 host1 host2 SimGrid-3.11/teshsuite/bug-17132/bug-17132.c000644 001750 001750 00000002356 12342443665 016704 0ustar00cici000000 000000 /* Copyright (c) 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "xbt/log.h" #include #include XBT_LOG_NEW_DEFAULT_CATEGORY(MM_mpi, "Messages for this SMPI test"); int main(int argc, char ** argv) { size_t err; size_t M = 8*1024; size_t N = 32*1024; MPI_Init(&argc, &argv); int rank; MPI_Comm_rank(MPI_COMM_WORLD,&rank); double *a = malloc(sizeof(double) * M); double *b = malloc(sizeof(double) * N); // A broadcast err = MPI_Bcast(a, M, MPI_DOUBLE, 0, MPI_COMM_WORLD); if (err != MPI_SUCCESS) { perror("Error Bcast A\n"); MPI_Finalize(); exit(-1); } // Uncommenting this barrier fixes it! // MPI_Barrier(MPI_COMM_WORLD); // Another broadcast err = MPI_Bcast(b, N, MPI_DOUBLE, 0, MPI_COMM_WORLD ); if (err != MPI_SUCCESS) { perror("Error Bcast B\n"); MPI_Finalize(); exit(-1); } // Commenting out this barrier fixes it!! MPI_Barrier(MPI_COMM_WORLD); if(rank==0) { printf("Walltime = %g\n",MPI_Wtime()); } MPI_Finalize(); free(a); free(b); return 0; } SimGrid-3.11/teshsuite/bug-17132/bug-17132-surf-debug.tesh000644 001750 001750 00000000304 12342443665 021455 0ustar00cici000000 000000 ! output ignore $ ../../smpi_script/bin/smpirun -np 16 -platform ${srcdir:=.}/small_platform.xml -hostfile ${srcdir:=.}/hostfile.txt ./bug-17132 --cfg=smpi/cpu_threshold:-1 --log=surf.thres:debug SimGrid-3.11/teshsuite/bug-17132/small_platform.xml000644 001750 001750 00000000571 12342443670 021037 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/bug-17132/README000644 001750 001750 00000000577 12342443666 016174 0ustar00cici000000 000000 This is the bug #17132 described on gforge [1]. This small SMPI code triggers an issue in SURF, which is still to be debugged. The problem seems to be related to the order of events, as changing it (with another platform or another message size or a MPI_barrier in between) fixes the problem. [1] https://gforge.inria.fr/tracker/index.php?func=detail&aid=17132&group_id=12&atid=165SimGrid-3.11/teshsuite/bug-17132/CMakeLists.txt000644 001750 001750 00000002056 12342443654 020043 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(bug-17132 ${CMAKE_HOME_DIRECTORY}/teshsuite/bug-17132/bug-17132.c) target_link_libraries(bug-17132 simgrid) set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/bug-17132.tesh ${CMAKE_CURRENT_SOURCE_DIR}/bug-17132-surf-debug.tesh PARENT_SCOPE) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/small_platform.xml PARENT_SCOPE) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/bug-17132.c PARENT_SCOPE) set(bin_files ${bin_files} PARENT_SCOPE) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/hostfile.txt ${CMAKE_CURRENT_SOURCE_DIR}/README PARENT_SCOPE) endif(enable_smpi) SimGrid-3.11/teshsuite/smpi/000755 001750 001750 00000000000 12342443657 015023 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/scatter/000755 001750 001750 00000000000 12342443665 016467 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/scatter/scatter_coll.tesh000644 001750 001750 00000002413 12342443665 022032 0ustar00cici000000 000000 # Smpi scatter collectives tests ! setenv LD_LIBRARY_PATH=../../lib ! output sort p Test scatter $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 16 --log=xbt_cfg.thres:critical ${bindir:=.}/scatter --log=smpi_kernel.thres:warning > [0] ok. > [0] ok. > [10] ok. > [10] ok. > [11] ok. > [11] ok. > [12] ok. > [12] ok. > [13] ok. > [13] ok. > [14] ok. > [14] ok. > [15] ok. > [15] ok. > [1] ok. > [1] ok. > [2] ok. > [2] ok. > [3] ok. > [3] ok. > [4] ok. > [4] ok. > [5] ok. > [5] ok. > [6] ok. > [6] ok. > [7] ok. > [7] ok. > [8] ok. > [8] ok. > [9] ok. > [9] ok. > ** IBM Test Result: ... > ** Small Test Result: ... > You requested to use 16 processes, but there is only 5 processes in your hostfile... > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [rank 0] -> Tremblay > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [rank 12] -> Fafard > [rank 13] -> Ginette > [rank 14] -> Bourassa > [rank 15] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa SimGrid-3.11/teshsuite/smpi/scatter/scatter.c000644 001750 001750 00000007352 12342443660 020302 0ustar00cici000000 000000 /* Copyright (c) 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /** * MESSAGE PASSING INTERFACE TEST CASE SUITE * * Copyright IBM Corp. 1995 * * IBM Corp. hereby grants a non-exclusive license to use, copy, modify, and *distribute this software for any purpose and without fee provided that the *above copyright notice and the following paragraphs appear in all copies. * IBM Corp. makes no representation that the test cases comprising this * suite are correct or are an accurate representation of any standard. * In no event shall IBM be liable to any party for direct, indirect, special * incidental, or consequential damage arising out of the use of this software * even if IBM Corp. has been advised of the possibility of such damage. * IBM CORP. SPECIFICALLY DISCLAIMS ANY WARRANTIES INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS AND IBM * CORP. HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, * ENHANCEMENTS, OR MODIFICATIONS. * *************************************************************************** **/ #include #include static int ibm_test(int rank, int size) { #define MAXLEN 10000 int success = 1; int root = 0; int i, j, k; int *out; int *in; out = malloc(MAXLEN * 64 * sizeof(int)); in = malloc(MAXLEN * sizeof(int)); for (j = 1; j <= MAXLEN; j *= 10) { root = (root + 1) % size; if (rank == root) for (i = 0; i < j * size; i++) out[i] = i; MPI_Scatter(out, j, MPI_INT, in, j, MPI_INT, root, MPI_COMM_WORLD); for (k = 0; k < j; k++) { if (in[k] != k + rank * j) { fprintf(stderr, "task %d bad answer (%d) at index %d k of %d (should be %d)", rank, in[k], k, j, (k + rank * j)); return (0); } } } free(out); free(in); MPI_Barrier(MPI_COMM_WORLD); return (success); } /** * small test: the root sends a single distinct double to other processes **/ static int small_test(int rank, int size) { int success = 1; int retval; int sendcount = 1; // one double to each process int recvcount = 1; int i; double *sndbuf = NULL; double rcvd; int root = 0; // arbitrary choice // on root, initialize sendbuf if (root == rank) { sndbuf = malloc(size * sizeof(double)); for (i = 0; i < size; i++) { sndbuf[i] = (double) i; } } retval = MPI_Scatter(sndbuf, sendcount, MPI_DOUBLE, &rcvd, recvcount, MPI_DOUBLE, root, MPI_COMM_WORLD); if (root == rank) { free(sndbuf); } if (retval != MPI_SUCCESS) { fprintf(stderr, "(%s:%d) MPI_Scatter() returned retval=%d\n", __FILE__, __LINE__, retval); return 0; } // verification if ((double) rank != rcvd) { fprintf(stderr, "[%d] has %f instead of %d\n", rank, rcvd, rank); success = 0; } return (success); } int main(int argc, char **argv) { int size, rank; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); /* test 1 */ if (0 == rank) printf("** Small Test Result: ...\n"); if (!small_test(rank, size)) printf("\t[%d] failed.\n", rank); else printf("\t[%d] ok.\n", rank); MPI_Barrier(MPI_COMM_WORLD); /* test 2 */ if (0 == rank) printf("** IBM Test Result: ...\n"); if (!ibm_test(rank, size)) printf("\t[%d] failed.\n", rank); else printf("\t[%d] ok.\n", rank); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/scatter/CMakeLists.txt000644 001750 001750 00000001422 12342443654 021224 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(scatter scatter.c) target_link_libraries(scatter simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/scatter_coll.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/scatter.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/alltoall/000755 001750 001750 00000000000 12342443665 016626 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/alltoall/alltoall_basic.c000644 001750 001750 00000002762 12342443660 021741 0ustar00cici000000 000000 /* Copyright (c) 2009-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include #include #include "mpi.h" #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #define EXIT_FAILURE 1 #endif int main(int argc, char *argv[]) { int rank, size; int i; int *sb; int *rb; int status; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); sb = (int *) malloc(size * sizeof(int)); if (!sb) { perror("can't allocate send buffer"); fflush(stderr); MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE); exit(EXIT_FAILURE); } rb = (int *) malloc(size * sizeof(int)); if (!rb) { perror("can't allocate recv buffer"); fflush(stderr); free(sb); MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE); exit(EXIT_FAILURE); } for (i = 0; i < size; ++i) { sb[i] = rank + 1; rb[i] = 0; } status = MPI_Alltoall(sb, 1, MPI_INT, rb, 1, MPI_INT, MPI_COMM_WORLD); printf("[%d] rcvbuf=[", rank); for (i = 0; i < size; i++) printf("%d ", rb[i]); printf("]\n"); if (rank == 0) { if (status != MPI_SUCCESS) { printf("all_to_all returned %d\n", status); fflush(stdout); } } free(sb); free(rb); MPI_Finalize(); return (EXIT_SUCCESS); } SimGrid-3.11/teshsuite/smpi/alltoall/alltoall_coll.tesh000644 001750 001750 00000006246 12342443665 022340 0ustar00cici000000 000000 # Smpi Alltoall collectives tests ! setenv LD_LIBRARY_PATH=../../lib ! output sort p Test all to all $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 16 --log=xbt_cfg.thres:critical ${bindir:=.}/alltoall_coll -q --log=smpi_kernel.thres:warning > You requested to use 16 processes, but there is only 5 processes in your hostfile... > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [rank 12] -> Fafard > [rank 13] -> Ginette > [rank 14] -> Bourassa > [rank 15] -> Tremblay > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0] sndbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ] > [1] sndbuf=[16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [2] sndbuf=[32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 ] > [3] sndbuf=[48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 ] > [4] sndbuf=[64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 ] > [5] sndbuf=[80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 ] > [6] sndbuf=[96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 ] > [7] sndbuf=[112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 ] > [8] sndbuf=[128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 ] > [9] sndbuf=[144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 ] > [10] sndbuf=[160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 ] > [11] sndbuf=[176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 ] > [12] sndbuf=[192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 ] > [13] sndbuf=[208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 ] > [14] sndbuf=[224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 ] > [15] sndbuf=[240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 ] > [0] rcvbuf=[0 16 32 48 64 80 96 112 128 144 160 176 192 208 224 240 ] > [1] rcvbuf=[1 17 33 49 65 81 97 113 129 145 161 177 193 209 225 241 ] > [2] rcvbuf=[2 18 34 50 66 82 98 114 130 146 162 178 194 210 226 242 ] > [3] rcvbuf=[3 19 35 51 67 83 99 115 131 147 163 179 195 211 227 243 ] > [4] rcvbuf=[4 20 36 52 68 84 100 116 132 148 164 180 196 212 228 244 ] > [5] rcvbuf=[5 21 37 53 69 85 101 117 133 149 165 181 197 213 229 245 ] > [6] rcvbuf=[6 22 38 54 70 86 102 118 134 150 166 182 198 214 230 246 ] > [7] rcvbuf=[7 23 39 55 71 87 103 119 135 151 167 183 199 215 231 247 ] > [8] rcvbuf=[8 24 40 56 72 88 104 120 136 152 168 184 200 216 232 248 ] > [9] rcvbuf=[9 25 41 57 73 89 105 121 137 153 169 185 201 217 233 249 ] > [10] rcvbuf=[10 26 42 58 74 90 106 122 138 154 170 186 202 218 234 250 ] > [11] rcvbuf=[11 27 43 59 75 91 107 123 139 155 171 187 203 219 235 251 ] > [12] rcvbuf=[12 28 44 60 76 92 108 124 140 156 172 188 204 220 236 252 ] > [13] rcvbuf=[13 29 45 61 77 93 109 125 141 157 173 189 205 221 237 253 ] > [14] rcvbuf=[14 30 46 62 78 94 110 126 142 158 174 190 206 222 238 254 ] > [15] rcvbuf=[15 31 47 63 79 95 111 127 143 159 175 191 207 223 239 255 ] SimGrid-3.11/teshsuite/smpi/alltoall/alltoall2.c000644 001750 001750 00000006010 12342443660 020650 0ustar00cici000000 000000 /* Copyright (c) 2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /**************************************************************************** MESSAGE PASSING INTERFACE TEST CASE SUITE Copyright IBM Corp. 1995 IBM Corp. hereby grants a non-exclusive license to use, copy, modify, and distribute this software for any purpose and without fee provided that the above copyright notice and the following paragraphs appear in all copies. IBM Corp. makes no representation that the test cases comprising this suite are correct or are an accurate representation of any standard. In no event shall IBM be liable to any party for direct, indirect, special incidental, or consequential damage arising out of the use of this software even if IBM Corp. has been advised of the possibility of such damage. IBM CORP. SPECIFICALLY DISCLAIMS ANY WARRANTIES INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS AND IBM CORP. HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. **************************************************************************** These test cases reflect an interpretation of the MPI Standard. They are are, in most cases, unit tests of specific MPI behaviors. If a user of any test case from this set believes that the MPI Standard requires behavior different than that implied by the test case we would appreciate feedback. Comments may be sent to: Richard Treumann treumann@kgn.ibm.com **************************************************************************** */ #include #include #include #include #include "mpi.h" #define MAXLEN 10000 int main(int argc, char *argv[]) { #define N 1000000 int *out, *in, i, j, k; int myself, tasks; out = malloc(N * sizeof(int)); in = malloc(N * sizeof(int)); if ((out == NULL) || (in == NULL)) { printf("Error: cannot allocate N bytes for in or out arrays\n"); exit(1); } MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &myself); MPI_Comm_size(MPI_COMM_WORLD, &tasks); for (j = 1; j <= MAXLEN; j *= 10) { if (0 == myself) { printf("* calling MPI_Alltoall with buffers of %d ints\n", j); } for (i = 0; i < j * tasks; i++) out[i] = myself; MPI_Alltoall(out, j, MPI_INT, in, j, MPI_INT, MPI_COMM_WORLD); for (i = 0; i < tasks; i++) { for (k = 0; k < j; k++) { if (in[k + i * j] != i) { printf("<%d> bad answer (%d) at index %d of %d (should be %d)\n", myself, in[k + i * j], k + i * j, j * tasks, i); break; } } } } MPI_Barrier(MPI_COMM_WORLD); if (myself == 0) printf("TEST COMPLETE\n"); MPI_Finalize(); return EXIT_SUCCESS; } SimGrid-3.11/teshsuite/smpi/alltoall/alltoall_coll.c000644 001750 001750 00000002476 12342443660 021613 0ustar00cici000000 000000 /* Copyright (c) 2009-2010, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include #include #include "mpi.h" #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #define EXIT_FAILURE 1 #endif int main(int argc, char *argv[]) { int rank, size; int i; int *sb; int *rb; int status; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); sb = (int *) xbt_malloc(size * sizeof(int) * 2); rb = (int *) xbt_malloc(size * sizeof(int) * 2); for (i = 0; i < size; ++i) { sb[i] = rank*size + i; rb[i] = 0; } printf("[%d] sndbuf=[", rank); for (i = 0; i < size; i++) printf("%d ", sb[i]); printf("]\n"); status = MPI_Alltoall(sb, 1, MPI_INT, rb, 1, MPI_INT, MPI_COMM_WORLD); printf("[%d] rcvbuf=[", rank); for (i = 0; i < size; i++) printf("%d ", rb[i]); printf("]\n"); if (rank == 0) { if (status != MPI_SUCCESS) { printf("all_to_all returned %d\n", status); fflush(stdout); } } free(sb); free(rb); MPI_Finalize(); return (EXIT_SUCCESS); } SimGrid-3.11/teshsuite/smpi/alltoall/CMakeLists.txt000644 001750 001750 00000002071 12342443654 021364 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(alltoall2 alltoall2.c) add_executable(alltoall_basic alltoall_basic.c) add_executable(alltoall_coll alltoall_coll.c) target_link_libraries(alltoall2 simgrid) target_link_libraries(alltoall_basic simgrid) target_link_libraries(alltoall_coll simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/alltoall_coll.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/alltoall_coll.c ${CMAKE_CURRENT_SOURCE_DIR}/alltoall_basic.c ${CMAKE_CURRENT_SOURCE_DIR}/alltoall2.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/allgatherv/000755 001750 001750 00000000000 12342443665 017153 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/allgatherv/allgatherv_coll.tesh000644 001750 001750 00000021124 12342443665 023202 0ustar00cici000000 000000 # Smpi Allgatherv collectives tests ! setenv LD_LIBRARY_PATH=../../lib ! output sort p Test allgatherv $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 16 --log=xbt_cfg.thres:critical ${bindir:=.}/allgatherv_coll --log=smpi_kernel.thres:warning > You requested to use 16 processes, but there is only 5 processes in your hostfile... > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [rank 12] -> Fafard > [rank 13] -> Ginette > [rank 14] -> Bourassa > [rank 15] -> Tremblay > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0] sndbuf=[0 ] > [1] sndbuf=[1 2 ] > [2] sndbuf=[3 4 5 ] > [3] sndbuf=[6 7 8 9 ] > [4] sndbuf=[10 11 12 13 14 ] > [5] sndbuf=[15 16 17 18 19 20 ] > [6] sndbuf=[21 22 23 24 25 26 27 ] > [7] sndbuf=[28 29 30 31 32 33 34 35 ] > [8] sndbuf=[36 37 38 39 40 41 42 43 44 ] > [9] sndbuf=[45 46 47 48 49 50 51 52 53 54 ] > [10] sndbuf=[55 56 57 58 59 60 61 62 63 64 65 ] > [11] sndbuf=[66 67 68 69 70 71 72 73 74 75 76 77 ] > [12] sndbuf=[78 79 80 81 82 83 84 85 86 87 88 89 90 ] > [13] sndbuf=[91 92 93 94 95 96 97 98 99 100 101 102 103 104 ] > [14] sndbuf=[105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 ] > [15] sndbuf=[120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [0] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [1] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [2] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [3] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [4] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [5] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [6] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [7] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [8] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [9] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [10] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [11] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [12] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [13] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [14] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] > [15] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 ] SimGrid-3.11/teshsuite/smpi/allgatherv/allgatherv_coll.c000644 001750 001750 00000003447 12342443660 022464 0ustar00cici000000 000000 /* Copyright (c) 2009-2010, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include #include #include "mpi.h" #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #define EXIT_FAILURE 1 #endif int main(int argc, char *argv[]) { int rank, size; int i; int *sb; int *rb; int *recv_counts; int *recv_disps; int recv_sb_size; int status; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); recv_counts = (int *) xbt_malloc(size * sizeof(int)); recv_disps = (int *) xbt_malloc(size * sizeof(int)); recv_sb_size = 0; for (i = 0; i < size; i++) { recv_counts[i] = i + 1; recv_disps[i] = recv_sb_size; recv_sb_size += i + 1; } sb = (int *) xbt_malloc(recv_counts[rank] * sizeof(int)); rb = (int *) xbt_malloc(recv_sb_size * sizeof(int)); for (i = 0; i < recv_counts[rank]; ++i) sb[i] = recv_disps[rank] + i; for (i = 0; i < recv_sb_size; ++i) rb[i] = -1; printf("[%d] sndbuf=[", rank); for (i = 0; i < recv_counts[rank]; i++) printf("%d ", sb[i]); printf("]\n"); status = MPI_Allgatherv(sb, recv_counts[rank], MPI_INT, rb, recv_counts, recv_disps, MPI_INT, MPI_COMM_WORLD); printf("[%d] rcvbuf=[", rank); for (i = 0; i < recv_sb_size; i++) printf("%d ", rb[i]); printf("]\n"); if (rank == 0) { if (status != MPI_SUCCESS) { printf("allgatherv returned %d\n", status); fflush(stdout); } } free(sb); free(rb); free(recv_counts); free(recv_disps); MPI_Finalize(); return (EXIT_SUCCESS); } SimGrid-3.11/teshsuite/smpi/allgatherv/CMakeLists.txt000644 001750 001750 00000001465 12342443654 021717 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(allgatherv_coll allgatherv_coll.c) target_link_libraries(allgatherv_coll simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/allgatherv_coll.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/allgatherv_coll.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/allreduce/000755 001750 001750 00000000000 12342443665 016762 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/allreduce/allreduce_coll_large.tesh000644 001750 001750 00000112035 12342443665 023774 0ustar00cici000000 000000 # Smpi Allreduce collectives tests ! setenv LD_LIBRARY_PATH=../../lib ! output sort ! timeout 20 p Test allreduce $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 16 --log=xbt_cfg.thres:critical ${bindir:=.}/allreduce_coll 30000 --log=smpi_kernel.thres:warning > You requested to use 16 processes, but there is only 5 processes in your hostfile... > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [rank 12] -> Fafard > [rank 13] -> Ginette > [rank 14] -> Bourassa > [rank 15] -> Tremblay > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [0] sndbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 ] > [10] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [10] sndbuf=[160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 ] > [11] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [11] sndbuf=[176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 ] > [12] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [12] sndbuf=[192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 ] > [13] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [13] sndbuf=[208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 ] > [14] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [14] sndbuf=[224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 ] > [15] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [15] sndbuf=[240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 ] > [1] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [1] sndbuf=[16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 ] > [2] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [2] sndbuf=[32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 ] > [3] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [3] sndbuf=[48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 ] > [4] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [4] sndbuf=[64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 ] > [5] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [5] sndbuf=[80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 ] > [6] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [6] sndbuf=[96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 ] > [7] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [7] sndbuf=[112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 ] > [8] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [8] sndbuf=[128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 ] > [9] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 2176 2192 2208 2224 2240 2256 2272 2288 2304 2320 2336 2352 2368 2384 2400 2416 2432 2448 2464 2480 2496 2512 2528 2544 2560 2576 2592 2608 2624 2640 2656 2672 2688 2704 2720 2736 2752 2768 2784 2800 2816 2832 2848 2864 2880 2896 2912 2928 2944 2960 2976 2992 3008 3024 3040 3056 3072 3088 3104 3120 3136 3152 3168 3184 3200 3216 3232 3248 3264 3280 3296 3312 3328 3344 3360 3376 3392 3408 3424 3440 3456 3472 3488 3504 3520 3536 3552 3568 3584 3600 3616 3632 3648 3664 3680 3696 3712 3728 3744 3760 3776 3792 3808 3824 3840 3856 3872 3888 3904 3920 3936 3952 3968 3984 4000 4016 4032 4048 4064 4080 4096 4112 4128 4144 4160 4176 4192 4208 4224 4240 4256 4272 4288 4304 4320 4336 4352 4368 4384 4400 4416 4432 4448 4464 4480 4496 4512 4528 4544 4560 4576 4592 4608 4624 4640 4656 4672 4688 4704 4720 4736 4752 4768 4784 4800 4816 4832 4848 4864 4880 4896 4912 4928 4944 4960 4976 4992 5008 5024 5040 5056 5072 5088 5104 5120 5136 5152 5168 5184 5200 5216 5232 5248 5264 5280 5296 5312 5328 5344 5360 5376 5392 5408 5424 5440 5456 5472 5488 5504 5520 5536 5552 5568 5584 5600 5616 5632 5648 5664 5680 5696 5712 5728 5744 5760 5776 5792 5808 5824 5840 5856 5872 5888 5904 5920 5936 5952 5968 5984 6000 ] > [9] sndbuf=[144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 ] SimGrid-3.11/teshsuite/smpi/allreduce/allreduce_coll.c000644 001750 001750 00000002754 12342443660 022102 0ustar00cici000000 000000 /* Copyright (c) 2009-2010, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include #include #include "mpi.h" #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #define EXIT_FAILURE 1 #endif //define MAXLEN 300000 int main(int argc, char *argv[]) { int rank, size; int i; int *sb; int *rb; int status; int mult=1; MPI_Init(&argc, &argv); int maxlen = argc >= 2 ? atoi(argv[1]) : 1; MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); if (maxlen>1)mult=size; sb = (int *) xbt_malloc(size *maxlen * sizeof(int)); rb = (int *) xbt_malloc(size *maxlen * sizeof(int)); for (i = 0; i < size *maxlen; ++i) { sb[i] = rank*size + i; rb[i] = 0; } printf("[%d] sndbuf=[", rank); for (i = 0; i < size *mult; i++) printf("%d ", sb[i]); printf("]\n"); status = MPI_Allreduce(sb, rb, size *maxlen, MPI_INT, MPI_SUM, MPI_COMM_WORLD); printf("[%d] rcvbuf=[", rank); for (i = 0; i < size *mult; i++)//do not print everything printf("%d ", rb[i]); printf("]\n"); if (rank == 0) { if (status != MPI_SUCCESS) { printf("all_to_all returned %d\n", status); fflush(stdout); } } free(sb); free(rb); MPI_Finalize(); return (EXIT_SUCCESS); } SimGrid-3.11/teshsuite/smpi/allreduce/allreduce_coll.tesh000644 001750 001750 00000007022 12342443665 022621 0ustar00cici000000 000000 # Smpi Allreduce collectives tests ! setenv LD_LIBRARY_PATH=../../lib ! output sort p Test allreduce $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 16 --log=xbt_cfg.thres:critical ${bindir:=.}/allreduce_coll --log=smpi_kernel.thres:warning > You requested to use 16 processes, but there is only 5 processes in your hostfile... > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [rank 12] -> Fafard > [rank 13] -> Ginette > [rank 14] -> Bourassa > [rank 15] -> Tremblay > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0] sndbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ] > [1] sndbuf=[16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [2] sndbuf=[32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 ] > [3] sndbuf=[48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 ] > [4] sndbuf=[64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 ] > [5] sndbuf=[80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 ] > [6] sndbuf=[96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 ] > [7] sndbuf=[112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 ] > [8] sndbuf=[128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 ] > [9] sndbuf=[144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 ] > [10] sndbuf=[160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 ] > [11] sndbuf=[176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 ] > [12] sndbuf=[192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 ] > [13] sndbuf=[208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 ] > [14] sndbuf=[224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 ] > [15] sndbuf=[240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 ] > [0] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [1] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [2] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [3] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [4] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [5] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [6] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [7] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [8] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [9] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [10] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [11] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [12] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [13] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [14] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [15] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] SimGrid-3.11/teshsuite/smpi/allreduce/allreduce.c000644 001750 001750 00000004561 12342443660 021067 0ustar00cici000000 000000 /* Copyright (c) 2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include /** * MESSAGE PASSING INTERFACE TEST CASE SUITE * * Copyright IBM Corp. 1995 * * IBM Corp. hereby grants a non-exclusive license to use, copy, modify, and *distribute this software for any purpose and without fee provided that the *above copyright notice and the following paragraphs appear in all copies. * IBM Corp. makes no representation that the test cases comprising this * suite are correct or are an accurate representation of any standard. * In no event shall IBM be liable to any party for direct, indirect, special * incidental, or consequential damage arising out of the use of this software * even if IBM Corp. has been advised of the possibility of such damage. * IBM CORP. SPECIFICALLY DISCLAIMS ANY WARRANTIES INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS AND IBM * CORP. HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, * ENHANCEMENTS, OR MODIFICATIONS. * *************************************************************************** **/ static int ibm_test(int rank, int size) { int success = 1; #define MAXLEN 10000 int root = 0, i, j, k; int out[MAXLEN]; int in[MAXLEN]; for (j = 1; j <= MAXLEN; j *= 10) { for (i = 0; i < j; i++) out[i] = i; MPI_Allreduce(out, in, j, MPI_INT, MPI_SUM, MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); if (rank == root) { for (k = 0; k < j; k++) { if (in[k] != k * size) { printf("bad answer (%d) at index %d of %d (should be %d)", in[k], k, j, k * size); success = 0; break; } } } } return (success); } int main(int argc, char **argv) { int size, rank; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (0 == rank) printf("** IBM Test Result: ... \n"); if (!ibm_test(rank, size)) printf("\t[%d] failed.\n", rank); else printf("\t[%d] ok.\n", rank); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/allreduce/CMakeLists.txt000644 001750 001750 00000001745 12342443654 021527 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(allreduce allreduce.c) add_executable(allreduce_coll allreduce_coll.c) target_link_libraries(allreduce simgrid) target_link_libraries(allreduce_coll simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/allreduce_coll.tesh ${CMAKE_CURRENT_SOURCE_DIR}/allreduce_coll_large.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/allreduce.c ${CMAKE_CURRENT_SOURCE_DIR}/allreduce_coll.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/hvector/000755 001750 001750 00000000000 12342443665 016474 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/hvector/hvector_test.c000644 001750 001750 00000002131 12342443660 021341 0ustar00cici000000 000000 /* Copyright (c) 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include "mpi.h" #define SIZE 4 int main(int argc, char **argv) { int rank, i, j; double a[SIZE][SIZE] = {{0}}; MPI_Datatype columntype; MPI_Init(&argc,&argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Type_hvector(SIZE, 1, SIZE*sizeof(double), MPI_DOUBLE, &columntype); MPI_Type_commit(&columntype); if (rank == 0) { for(i=0; i [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [rank 0] -> Tremblay > [rank 1] -> Jupiter > rank= 0, a[0][0]=0.000000 > rank= 0, a[0][1]=1.000000 > rank= 0, a[0][2]=2.000000 > rank= 0, a[0][3]=3.000000 > rank= 0, a[1][0]=4.000000 > rank= 0, a[1][1]=5.000000 > rank= 0, a[1][2]=6.000000 > rank= 0, a[1][3]=7.000000 > rank= 0, a[2][0]=8.000000 > rank= 0, a[2][1]=9.000000 > rank= 0, a[2][2]=10.000000 > rank= 0, a[2][3]=11.000000 > rank= 0, a[3][0]=12.000000 > rank= 0, a[3][1]=13.000000 > rank= 0, a[3][2]=14.000000 > rank= 0, a[3][3]=15.000000 > rank= 1, a[0][0]=0.000000 > rank= 1, a[0][1]=0.000000 > rank= 1, a[0][2]=0.000000 > rank= 1, a[0][3]=0.000000 > rank= 1, a[1][0]=4.000000 > rank= 1, a[1][1]=0.000000 > rank= 1, a[1][2]=0.000000 > rank= 1, a[1][3]=0.000000 > rank= 1, a[2][0]=8.000000 > rank= 1, a[2][1]=0.000000 > rank= 1, a[2][2]=0.000000 > rank= 1, a[2][3]=0.000000 > rank= 1, a[3][0]=12.000000 > rank= 1, a[3][1]=0.000000 > rank= 1, a[3][2]=0.000000 > rank= 1, a[3][3]=0.000000 SimGrid-3.11/teshsuite/smpi/hvector/CMakeLists.txt000644 001750 001750 00000001441 12342443654 021232 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(hvector_test hvector_test.c) target_link_libraries(hvector_test simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/hvector.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/hvector_test.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/indexed/000755 001750 001750 00000000000 12342443665 016442 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/indexed/indexed_test.c000644 001750 001750 00000002623 12342443660 021263 0ustar00cici000000 000000 /* Copyright (c) 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include "mpi.h" int main(int argc, char *argv[]) { int rank, size, i; MPI_Datatype type, type2; int blocklen[3] = { 2, 3, 1 }; int displacement[3] = { 0, 3, 8 }; int buffer[27]; MPI_Status status; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); if (size < 2) { printf("Please run with 2 processes.\n"); MPI_Finalize(); return 1; } MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Type_contiguous(3, MPI_INT, &type2); MPI_Type_commit(&type2); MPI_Type_indexed(3, blocklen, displacement, type2, &type); MPI_Type_commit(&type); if (rank == 0) { for (i=0; i<27; i++) buffer[i] = i; MPI_Send(buffer, 1, type, 1, 123, MPI_COMM_WORLD); } if (rank == 1) { for (i=0; i<27; i++) buffer[i] = -1; MPI_Recv(buffer, 1, type, 0, 123, MPI_COMM_WORLD, &status); for (i=0; i<27; i++) printf("buffer[%d] = %d\n", i, buffer[i]); fflush(stdout); } MPI_Type_free(&type); MPI_Type_free(&type2); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/indexed/indexed.tesh000644 001750 001750 00000002275 12342443665 020755 0ustar00cici000000 000000 p Test indexed ! setenv LD_LIBRARY_PATH=../../lib ! output sort $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 2 ${bindir:=.}/indexed_test -q --log=smpi_kernel.thres:warning > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [rank 0] -> Tremblay > [rank 1] -> Jupiter > buffer[0] = 0 > buffer[10] = 10 > buffer[11] = 11 > buffer[12] = 12 > buffer[13] = 13 > buffer[14] = 14 > buffer[15] = 15 > buffer[16] = 16 > buffer[17] = 17 > buffer[18] = -1 > buffer[19] = -1 > buffer[1] = 1 > buffer[20] = -1 > buffer[21] = -1 > buffer[22] = -1 > buffer[23] = -1 > buffer[24] = 24 > buffer[25] = 25 > buffer[26] = 26 > buffer[2] = 2 > buffer[3] = 3 > buffer[4] = 4 > buffer[5] = 5 > buffer[6] = -1 > buffer[7] = -1 > buffer[8] = -1 > buffer[9] = 9 SimGrid-3.11/teshsuite/smpi/indexed/CMakeLists.txt000644 001750 001750 00000001441 12342443654 021200 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(indexed_test indexed_test.c) target_link_libraries(indexed_test simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/indexed.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/indexed_test.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/hostfile000644 001750 001750 00000000051 12342443657 016557 0ustar00cici000000 000000 Tremblay Jupiter Fafard Ginette Bourassa SimGrid-3.11/teshsuite/smpi/pingpong/000755 001750 001750 00000000000 12342443665 016643 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/pingpong/TI_output.tesh000644 001750 001750 00000021544 12342443665 021472 0ustar00cici000000 000000 $ rm -rf ./out_ti.txt_files $ rm -rf ./out_in_ti.txt_files p Test output of time independent tracing p generate a trace with pingpong, and replay itself, then check that output trace of the second run is the same as in the first (once sorted) ! setenv LD_LIBRARY_PATH=../../lib ! output sort $ ${bindir:=.}/../../../bin/smpirun -trace-ti --cfg=tracing/filename:out_in_ti.txt --cfg=smpi/cpu_threshold:-1 -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 4 ${bindir:=.}/pingpong -q --log=smpi_kernel.thres:warning > *** Ping-pong test (MPI_Send/MPI_Recv) *** > == pivot=0 : pingpong [0] <--> [1] > == pivot=1 : pingpong [1] <--> [2] > == pivot=2 : pingpong [2] <--> [3] > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing' to 'yes' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/filename' to 'smpi_simgrid.txt' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi' to 'yes' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi/format' to 'TI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi/computing' to 'yes' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/filename' to 'out_in_ti.txt' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'smpi/cpu_threshold' to '-1' > [0] About to send 1st message '99' to process [1] > [0] Received reply message '100' from process [1] > [1] About to send 1st message '100' to process [2] > [1] About to send back message '100' to process [0] > [1] Received 1st message '99' from process [0] > [1] Received reply message '101' from process [2] > [1] increment message's value to '100' > [2] About to send 1st message '101' to process [3] > [2] About to send back message '101' to process [1] > [2] Received 1st message '100' from process [1] > [2] Received reply message '102' from process [3] > [2] increment message's value to '101' > [3] About to send back message '102' to process [2] > [3] Received 1st message '101' from process [2] > [3] increment message's value to '102' > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette $ ${bindir:=.}/../../../bin/smpirun -ext smpi_replay --log=replay.:critical -trace-ti --cfg=tracing/filename:out_ti.txt --cfg=smpi/cpu_threshold:-1 -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 4 ${bindir:=.}/../../../examples/smpi/smpi_replay ./out_in_ti.txt --log=smpi_kernel.thres:warning > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing' to 'yes' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/filename' to 'smpi_simgrid.txt' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi' to 'yes' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi/format' to 'TI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi/computing' to 'yes' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/filename' to 'out_ti.txt' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'smpi/cpu_threshold' to '-1' > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [Jupiter:1:(0) 0.016798] [smpi_replay/INFO] Simulation time 0.016798 ! output sort $ sh -c "cat ./out_ti.txt_files/*" > 0 init > 0 send 1 1 1 > 0 recv 1 1 1 > 0 finalize > 1 init > 1 recv 0 1 1 > 1 send 0 1 1 > 1 send 2 1 1 > 1 recv 2 1 1 > 1 finalize > 2 init > 2 recv 1 1 1 > 2 send 1 1 1 > 2 send 3 1 1 > 2 recv 3 1 1 > 2 finalize > 3 init > 3 recv 2 1 1 > 3 send 2 1 1 > 3 finalize ! output sort $ sh -c "cat ./out_in_ti.txt_files/*" > 0 init > 0 send 1 1 1 > 0 recv 1 1 1 > 0 finalize > 1 init > 1 recv 0 1 1 > 1 send 0 1 1 > 1 send 2 1 1 > 1 recv 2 1 1 > 1 finalize > 2 init > 2 recv 1 1 1 > 2 send 1 1 1 > 2 send 3 1 1 > 2 recv 3 1 1 > 2 finalize > 3 init > 3 recv 2 1 1 > 3 send 2 1 1 > 3 finalize $ rm -rf ./out_ti.txt_files $ rm -rf ./out_in_ti.txt_files $ rm out_ti.txt $ rm out_in_ti.txt p Same test, but only using one output file for all processes p generate a trace with pingpong, and replay itself, then check that output trace of the second run is the same as in the first (once sorted) ! output sort $ ${bindir:=.}/../../../bin/smpirun -trace-ti --cfg=tracing/filename:out_in_ti.txt --cfg=tracing/smpi/format/ti_one_file:yes -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 4 ${bindir:=.}/pingpong -q --log=smpi_kernel.thres:warning > *** Ping-pong test (MPI_Send/MPI_Recv) *** > == pivot=0 : pingpong [0] <--> [1] > == pivot=1 : pingpong [1] <--> [2] > == pivot=2 : pingpong [2] <--> [3] > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing' to 'yes' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/filename' to 'smpi_simgrid.txt' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi' to 'yes' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi/format' to 'TI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi/computing' to 'yes' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/filename' to 'out_in_ti.txt' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi/format/ti_one_file' to 'yes' > [0] About to send 1st message '99' to process [1] > [0] Received reply message '100' from process [1] > [1] About to send 1st message '100' to process [2] > [1] About to send back message '100' to process [0] > [1] Received 1st message '99' from process [0] > [1] Received reply message '101' from process [2] > [1] increment message's value to '100' > [2] About to send 1st message '101' to process [3] > [2] About to send back message '101' to process [1] > [2] Received 1st message '100' from process [1] > [2] Received reply message '102' from process [3] > [2] increment message's value to '101' > [3] About to send back message '102' to process [2] > [3] Received 1st message '101' from process [2] > [3] increment message's value to '102' > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette $ ${bindir:=.}/../../../bin/smpirun -ext smpi_replay --log=replay.:critical -trace-ti --cfg=tracing/filename:out_ti.txt --cfg=tracing/smpi/format/ti_one_file:yes -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 4 ${bindir:=.}/../../../examples/smpi/smpi_replay ./out_in_ti.txt --log=smpi_kernel.thres:warning > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing' to 'yes' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/filename' to 'smpi_simgrid.txt' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi' to 'yes' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi/format' to 'TI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi/computing' to 'yes' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/filename' to 'out_ti.txt' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'tracing/smpi/format/ti_one_file' to 'yes' > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [Jupiter:1:(0) 0.016798] [smpi_replay/INFO] Simulation time 0.016798 $ rm -rf ./out_ti.txt_files $ rm -rf ./out_in_ti.txt_files $ rm out_ti.txt $ rm out_in_ti.txt SimGrid-3.11/teshsuite/smpi/pingpong/pt2pt.tesh000644 001750 001750 00000004776 12342443665 020617 0ustar00cici000000 000000 p Test dsend ! setenv LD_LIBRARY_PATH=../../lib ! output sort $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 2 ${bindir:=.}/dsend -q --log=smpi_kernel.thres:warning > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [Jupiter:1:(0) 0.000000] [dsend/INFO] rank 1: data exchanged > [Tremblay:0:(0) 0.002945] [dsend/INFO] rank 0: data exchanged > [rank 0] -> Tremblay > [rank 1] -> Jupiter p Test pingpong ! setenv LD_LIBRARY_PATH=../../lib ! output sort $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 4 ${bindir:=.}/pingpong -q --log=smpi_kernel.thres:warning > *** Ping-pong test (MPI_Send/MPI_Recv) *** > == pivot=0 : pingpong [0] <--> [1] > == pivot=1 : pingpong [1] <--> [2] > == pivot=2 : pingpong [2] <--> [3] > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0] About to send 1st message '99' to process [1] > [0] Received reply message '100' from process [1] > [1] About to send 1st message '100' to process [2] > [1] About to send back message '100' to process [0] > [1] Received 1st message '99' from process [0] > [1] Received reply message '101' from process [2] > [1] increment message's value to '100' > [2] About to send 1st message '101' to process [3] > [2] About to send back message '101' to process [1] > [2] Received 1st message '100' from process [1] > [2] Received reply message '102' from process [3] > [2] increment message's value to '101' > [3] About to send back message '102' to process [2] > [3] Received 1st message '101' from process [2] > [3] increment message's value to '102' > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette SimGrid-3.11/teshsuite/smpi/pingpong/dsend.c000644 001750 001750 00000001756 12342443660 020110 0ustar00cici000000 000000 /* Copyright (c) 2011-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /* This program simply does a very small exchange to test whether using SIMIX dsend to model the eager mode works */ #include #include XBT_LOG_NEW_DEFAULT_CATEGORY(dsend,"the dsend test"); int main(int argc, char *argv[]) { int rank; int data=11; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (rank==1) { data=22; MPI_Send(&data,1,MPI_INT,(rank+1)%2,666,MPI_COMM_WORLD); // smpi_sleep(1000); } else { MPI_Recv(&data,1,MPI_INT,MPI_ANY_SOURCE,666,MPI_COMM_WORLD,NULL); if (data !=22) { printf("rank %d: Damn, data does not match (got %d)\n",rank, data); } } XBT_INFO("rank %d: data exchanged", rank); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/pingpong/pingpong.c000644 001750 001750 00000004312 12342443660 020623 0ustar00cici000000 000000 /* A simple example pingpong pogram to test MPI_Send and MPI_Recv */ /* Copyright (c) 2009-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include int main(int argc, char *argv[]) { const int tag1 = 42, tag2 = 43; /* Message tag */ int rank; int size; int msg = 99; int err; int pivot; MPI_Status status; err = MPI_Init(&argc, &argv); /* Initialize MPI */ if (err != MPI_SUCCESS) { printf("MPI initialization failed!\n"); exit(1); } MPI_Comm_size(MPI_COMM_WORLD, &size); /* Get nr of tasks */ MPI_Comm_rank(MPI_COMM_WORLD, &rank); /* Get id of this process */ if (size < 2) { printf("run this program with exactly 2 processes (-np 2)\n"); MPI_Finalize(); exit(0); } if (0 == rank) { printf("\n *** Ping-pong test (MPI_Send/MPI_Recv) ***\n\n"); } /* start pingpong tests between several pairs */ for (pivot = 0; pivot < size - 1; pivot++) { if (pivot == rank) { printf("\n== pivot=%d : pingpong [%d] <--> [%d]\n", pivot, pivot, pivot + 1); int dst = rank + 1; printf("[%d] About to send 1st message '%d' to process [%d]\n", rank, msg, dst); MPI_Send(&msg, 1, MPI_INT, dst, tag1, MPI_COMM_WORLD); MPI_Recv(&msg, 1, MPI_INT, dst, tag2, MPI_COMM_WORLD, &status); /* Receive a message */ printf("[%d] Received reply message '%d' from process [%d]\n", rank, msg, dst); } if ((pivot + 1) == rank) { int src = rank - 1; MPI_Recv(&msg, 1, MPI_INT, src, tag1, MPI_COMM_WORLD, &status); /* Receive a message */ printf("[%d] Received 1st message '%d' from process [%d]\n", rank, msg, src); msg++; printf("[%d] increment message's value to '%d'\n", rank, msg); printf("[%d] About to send back message '%d' to process [%d]\n", rank, msg, src); MPI_Send(&msg, 1, MPI_INT, src, tag2, MPI_COMM_WORLD); } } MPI_Finalize(); /* Terminate MPI */ return 0; } SimGrid-3.11/teshsuite/smpi/pingpong/CMakeLists.txt000644 001750 001750 00000001651 12342443654 021404 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(pingpong pingpong.c) add_executable(dsend dsend.c) target_link_libraries(pingpong simgrid) target_link_libraries(dsend simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/pt2pt.tesh ${CMAKE_CURRENT_SOURCE_DIR}/TI_output.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/dsend.c ${CMAKE_CURRENT_SOURCE_DIR}/pingpong.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/bcast/000755 001750 001750 00000000000 12342443665 016116 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/bcast/bcast_coll.c000644 001750 001750 00000002664 12342443660 020372 0ustar00cici000000 000000 /* Copyright (c) 2009, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include int main(int argc, char **argv) { int i, size, rank; int count = 2048; int *values; int status; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); values = (int *) xbt_malloc(count * sizeof(int)); for (i = 0; i < count; i++) values[i] = (0 == rank) ? 17 : 3; MPI_Bcast(values, count, MPI_INT, 0, MPI_COMM_WORLD); int good = 0; for (i = 0; i < count; i++) if (values[i]==17) good++; printf("[%d] number of values equals to 17: %d\n", rank, good); MPI_Barrier(MPI_COMM_WORLD); xbt_free(values); count = 4096; values = (int *) xbt_malloc(count * sizeof(int)); for (i = 0; i < count; i++) values[i] = (size -1 == rank) ? 17 : 3; status = MPI_Bcast(values, count, MPI_INT, size-1, MPI_COMM_WORLD); good = 0; for (i = 0; i < count; i++) if (values[i]==17) good++; printf("[%d] number of values equals to 17: %d\n", rank, good); if (rank == 0) { if (status != MPI_SUCCESS) { printf("bcast returned %d\n", status); fflush(stdout); } } xbt_free(values); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/bcast/bcast_coll.tesh000644 001750 001750 00000004270 12342443665 021113 0ustar00cici000000 000000 p Test Broadcast with more processes than hosts ! setenv LD_LIBRARY_PATH=../../lib ! output sort $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 16 --log=xbt_cfg.thres:critical ${bindir:=.}/bcast_coll --log=smpi_kernel.thres:warning > You requested to use 16 processes, but there is only 5 processes in your hostfile... > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [rank 12] -> Fafard > [rank 13] -> Ginette > [rank 14] -> Bourassa > [rank 15] -> Tremblay > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0] number of values equals to 17: 2048 > [0] number of values equals to 17: 4096 > [10] number of values equals to 17: 2048 > [10] number of values equals to 17: 4096 > [11] number of values equals to 17: 2048 > [11] number of values equals to 17: 4096 > [12] number of values equals to 17: 2048 > [12] number of values equals to 17: 4096 > [13] number of values equals to 17: 2048 > [13] number of values equals to 17: 4096 > [14] number of values equals to 17: 2048 > [14] number of values equals to 17: 4096 > [15] number of values equals to 17: 2048 > [15] number of values equals to 17: 4096 > [1] number of values equals to 17: 2048 > [1] number of values equals to 17: 4096 > [2] number of values equals to 17: 2048 > [2] number of values equals to 17: 4096 > [3] number of values equals to 17: 2048 > [3] number of values equals to 17: 4096 > [4] number of values equals to 17: 2048 > [4] number of values equals to 17: 4096 > [5] number of values equals to 17: 2048 > [5] number of values equals to 17: 4096 > [6] number of values equals to 17: 2048 > [6] number of values equals to 17: 4096 > [7] number of values equals to 17: 2048 > [7] number of values equals to 17: 4096 > [8] number of values equals to 17: 2048 > [8] number of values equals to 17: 4096 > [9] number of values equals to 17: 2048 > [9] number of values equals to 17: 4096 SimGrid-3.11/teshsuite/smpi/bcast/bcast.c000644 001750 001750 00000001741 12342443660 017354 0ustar00cici000000 000000 /* Copyright (c) 2009, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include int main(int argc, char **argv) { int size, rank; int value = 3; double start_timer; int quiet = 0; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (argc > 1 && !strcmp(argv[1], "-q")) quiet = 1; start_timer = MPI_Wtime(); if (0 == rank) { value = 17; } MPI_Bcast(&value, 1, MPI_INT, 0, MPI_COMM_WORLD); if (value != 17) { printf("node %d has value %d after broadcast\n", rank, value); } MPI_Barrier(MPI_COMM_WORLD); if (0 == rank && !quiet) printf("Elapsed time on rank %d: %f s\n", rank, MPI_Wtime() - start_timer); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/bcast/bcast.tesh000644 001750 001750 00000005405 12342443665 020103 0ustar00cici000000 000000 # use the tested library, not the installed one # (since we want to pass it to the child, it has to be redefined before each command) # Go for the first test p Test Broadcast with less processes than hosts $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 3 ${bindir:=.}/bcast -q --log=smpi_kernel.thres:warning > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) # second test p Test Broadcast with as much processes than hosts ! setenv LD_LIBRARY_PATH=../../lib $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 5 ${bindir:=.}/bcast -q --log=smpi_kernel.thres:warning > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) # Another test p Test Broadcast with more processes than hosts ! setenv LD_LIBRARY_PATH=../../lib $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 12 ${bindir:=.}/bcast -q --log=smpi_kernel.thres:warning > You requested to use 12 processes, but there is only 5 processes in your hostfile... > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) SimGrid-3.11/teshsuite/smpi/bcast/CMakeLists.txt000644 001750 001750 00000001662 12342443654 020661 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(bcast bcast.c) add_executable(bcast_coll bcast_coll.c) target_link_libraries(bcast simgrid) target_link_libraries(bcast_coll simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/bcast.tesh ${CMAKE_CURRENT_SOURCE_DIR}/bcast_coll.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/bcast.c ${CMAKE_CURRENT_SOURCE_DIR}/bcast_coll.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/gather/000755 001750 001750 00000000000 12342443665 016274 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/gather/gather_coll.tesh000644 001750 001750 00000002500 12342443665 021441 0ustar00cici000000 000000 # Smpi Alltoall collectives tests ! setenv LD_LIBRARY_PATH=../../lib ! output sort ! timeout 30 p Test all to all $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 16 --log=xbt_cfg.thres:critical ${bindir:=.}/gather_coll --log=smpi_kernel.thres:warning > You requested to use 16 processes, but there is only 5 processes in your hostfile... > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [rank 12] -> Fafard > [rank 13] -> Ginette > [rank 14] -> Bourassa > [rank 15] -> Tremblay > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [0] sndbuf=[0 1 ] > [1] sndbuf=[2 3 ] > [2] sndbuf=[4 5 ] > [3] sndbuf=[6 7 ] > [4] sndbuf=[8 9 ] > [5] sndbuf=[10 11 ] > [6] sndbuf=[12 13 ] > [7] sndbuf=[14 15 ] > [8] sndbuf=[16 17 ] > [9] sndbuf=[18 19 ] > [10] sndbuf=[20 21 ] > [11] sndbuf=[22 23 ] > [12] sndbuf=[24 25 ] > [13] sndbuf=[26 27 ] > [14] sndbuf=[28 29 ] > [15] sndbuf=[30 31 ] SimGrid-3.11/teshsuite/smpi/gather/gather_coll.c000644 001750 001750 00000002674 12342443660 020727 0ustar00cici000000 000000 /* Copyright (c) 2009-2010, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include #include #include "mpi.h" #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #define EXIT_FAILURE 1 #endif int main(int argc, char *argv[]) { int rank, size; int i; int *sb; int *rb; int status; int root = 0; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); int count = 2; sb = (int *) xbt_malloc(count * sizeof(int)); rb = (int *) xbt_malloc(count * size * sizeof(int)); for (i = 0; i < count; ++i) sb[i] = rank * count + i; for (i = 0; i < count * size; ++i) rb[i] = 0; printf("[%d] sndbuf=[", rank); for (i = 0; i < count; i++) printf("%d ", sb[i]); printf("]\n"); status = MPI_Gather(sb, count, MPI_INT, rb, count, MPI_INT, root, MPI_COMM_WORLD); if (rank == root) { printf("[%d] rcvbuf=[", rank); for (i = 0; i < count * size; i++) printf("%d ", rb[i]); printf("]\n"); if (status != MPI_SUCCESS) { printf("allgather returned %d\n", status); fflush(stdout); } } free(sb); free(rb); MPI_Barrier(MPI_COMM_WORLD); MPI_Finalize(); return (EXIT_SUCCESS); } SimGrid-3.11/teshsuite/smpi/gather/CMakeLists.txt000644 001750 001750 00000001441 12342443654 021032 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(gather_coll gather_coll.c) target_link_libraries(gather_coll simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/gather_coll.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/gather_coll.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/struct/000755 001750 001750 00000000000 12342443665 016346 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/struct/struct_test.c000644 001750 001750 00000003637 12342443660 021101 0ustar00cici000000 000000 /* Copyright (c) 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include "mpi.h" int main( argc, argv ) int argc; char **argv; { int rank; struct { int a;int c; double b;int tab[2][3];} value; MPI_Datatype mystruct; int blocklens[3]; MPI_Aint indices[3]; MPI_Datatype old_types[3], type2; int i,j; MPI_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); int tab[2][3]={{1*rank,2*rank,3*rank},{7*rank,8*rank,9*rank}}; MPI_Type_contiguous(3, MPI_INT, &type2); MPI_Type_commit(&type2); /* One value of each type, and two for the contiguous one */ blocklens[0] = 1; blocklens[1] = 1; blocklens[2] = 2; /* The base types */ old_types[0] = MPI_INT; old_types[1] = MPI_DOUBLE; old_types[2] = type2; /* The locations of each element */ MPI_Address( &value.a, &indices[0] ); MPI_Address( &value.b, &indices[1] ); MPI_Address( &tab, &indices[2] ); /* Make relative */ indices[2] = indices[2] - indices[0]; indices[1] = indices[1] - indices[0]; indices[0] = 0; MPI_Type_struct( 3, blocklens, indices, old_types, &mystruct ); MPI_Type_commit( &mystruct ); if (rank == 0){ value.a=-2; value.b=8.0; }else{ value.a=10000; value.b=5.0; } MPI_Bcast( &value, 1, mystruct, 0, MPI_COMM_WORLD ); printf( "Process %d got %d (-2?) and %f (8.0?), tab (should be all 0): ", rank, value.a, value.b ); for(j=0; j<2;j++ ) for(i=0; i<3;i++ ) printf("%d ", tab[j][i]); printf("\n"); /* Clean up the type */ MPI_Type_free( &mystruct ); MPI_Type_free( &type2 ); MPI_Finalize( ); return 0; } SimGrid-3.11/teshsuite/smpi/struct/struct.tesh000644 001750 001750 00000001611 12342443665 020556 0ustar00cici000000 000000 p Test struct ! setenv LD_LIBRARY_PATH=../../lib ! output sort $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 2 ${bindir:=.}/struct_test -q --log=smpi_kernel.thres:warning > Process 0 got -2 (-2?) and 8.000000 (8.0?), tab (should be all 0): 0 0 0 0 0 0 > Process 1 got -2 (-2?) and 8.000000 (8.0?), tab (should be all 0): 0 0 0 0 0 0 > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [rank 0] -> Tremblay > [rank 1] -> Jupiter SimGrid-3.11/teshsuite/smpi/struct/CMakeLists.txt000644 001750 001750 00000001434 12342443654 021106 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(struct_test struct_test.c) target_link_libraries(struct_test simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/struct.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/struct_test.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/alltoallv/000755 001750 001750 00000000000 12342443665 017014 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/alltoallv/alltoallv_coll.c000644 001750 001750 00000007024 12342443660 022161 0ustar00cici000000 000000 /* Copyright (c) 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include #include "mpi.h" /* This program tests MPI_Alltoallv by having processor i send different amounts of data to each processor. Because there are separate send and receive types to alltoallv, there need to be tests to rearrange data on the fly. Not done yet. The first test sends i items to processor i from all processors. Currently, the test uses only MPI_INT; this is adequate for testing systems that use point-to-point operations */ /* example values: * For 3 processes: * <0> sbuf: (#9): [0][1][2][3][4][5][6][7][8] <0> scount: (#3): [0][1][2] <0> rcount: (#3): [0][0][0] <0> sdisp: (#3): [0][1][3] <0> rdisp: (#3): [0][0][0] <1> sbuf: (#9): [100][101][102][103][104][105][106][107][108] <1> scount: (#3): [0][1][2] <1> rcount: (#3): [1][1][1] <1> sdisp: (#3): [0][1][3] <1> rdisp: (#3): [0][1][2] <2> sbuf: (#9): [200][201][202][203][204][205][206][207][208] <2> scount: (#3): [0][1][2] <2> rcount: (#3): [2][2][2] <2> sdisp: (#3): [0][1][3] <2> rdisp: (#3): [0][2][4] after MPI_Alltoallv : <0> rbuf: (#9): [-1][-1][-1][-1][-1][-1][-1][-1][-1] <1> rbuf: (#9): [1][101][201][-1][-1][-1][-1][-1][-1] <2> rbuf: (#9): [3][4][103][104][203][204][-1][-1][-1] */ static void print_buffer_int(void *buf, int len, char *msg, int rank) { int tmp, *v; printf("[%d] %s (#%d): ", rank, msg, len); for (tmp = 0; tmp < len; tmp++) { v = buf; printf("[%d]", v[tmp]); } printf("\n"); free(msg); } int main(int argc, char **argv) { MPI_Comm comm; int *sbuf, *rbuf; int rank, size; int *sendcounts, *recvcounts, *rdispls, *sdispls; int i; MPI_Init(&argc, &argv); comm = MPI_COMM_WORLD; /* Create the buffer */ MPI_Comm_size(comm, &size); MPI_Comm_rank(comm, &rank); sbuf = (int *) xbt_malloc(size * size * sizeof(int)); rbuf = (int *) xbt_malloc(size * size * sizeof(int)); /* Load up the buffers */ for (i = 0; i < size * size; i++) { sbuf[i] = i + 100 * rank; rbuf[i] = -1; } /* Create and load the arguments to alltoallv */ sendcounts = (int *) xbt_malloc(size * sizeof(int)); recvcounts = (int *) xbt_malloc(size * sizeof(int)); rdispls = (int *) xbt_malloc(size * sizeof(int)); sdispls = (int *) xbt_malloc(size * sizeof(int)); for (i = 0; i < size; i++) { sendcounts[i] = i; recvcounts[i] = rank; rdispls[i] = i * rank; sdispls[i] = (i * (i + 1)) / 2; } print_buffer_int( sbuf, size*size, strdup("sbuf:"),rank); print_buffer_int( sendcounts, size, strdup("scount:"),rank); print_buffer_int( recvcounts, size, strdup("rcount:"),rank); print_buffer_int( sdispls, size, strdup("sdisp:"),rank); print_buffer_int( rdispls, size, strdup("rdisp:"),rank); MPI_Alltoallv(sbuf, sendcounts, sdispls, MPI_INT, rbuf, recvcounts, rdispls, MPI_INT, comm); print_buffer_int( rbuf, size*size, strdup("rbuf:"),rank); MPI_Barrier(MPI_COMM_WORLD); if (0 == rank) { printf("Alltoallv TEST COMPLETE.\n"); } free(sdispls); free(rdispls); free(recvcounts); free(sendcounts); free(rbuf); free(sbuf); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/alltoallv/alltoallv_coll.tesh000644 001750 001750 00000135315 12342443665 022714 0ustar00cici000000 000000 # Smpi Alltoall collectives tests ! setenv LD_LIBRARY_PATH=../../lib ! output sort p Test all to all $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 16 --log=xbt_cfg.thres:critical ${bindir:=.}/alltoallv_coll --log=smpi_kernel.thres:warning > You requested to use 16 processes, but there is only 5 processes in your hostfile... > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [rank 12] -> Fafard > [rank 13] -> Ginette > [rank 14] -> Bourassa > [rank 15] -> Tremblay > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0] rbuf: (#256): [-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [0] rcount: (#16): [0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0] > [0] rdisp: (#16): [0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0] > [0] sbuf: (#256): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20][21][22][23][24][25][26][27][28][29][30][31][32][33][34][35][36][37][38][39][40][41][42][43][44][45][46][47][48][49][50][51][52][53][54][55][56][57][58][59][60][61][62][63][64][65][66][67][68][69][70][71][72][73][74][75][76][77][78][79][80][81][82][83][84][85][86][87][88][89][90][91][92][93][94][95][96][97][98][99][100][101][102][103][104][105][106][107][108][109][110][111][112][113][114][115][116][117][118][119][120][121][122][123][124][125][126][127][128][129][130][131][132][133][134][135][136][137][138][139][140][141][142][143][144][145][146][147][148][149][150][151][152][153][154][155][156][157][158][159][160][161][162][163][164][165][166][167][168][169][170][171][172][173][174][175][176][177][178][179][180][181][182][183][184][185][186][187][188][189][190][191][192][193][194][195][196][197][198][199][200][201][202][203][204][205][206][207][208][209][210][211][212][213][214][215][216][217][218][219][220][221][222][223][224][225][226][227][228][229][230][231][232][233][234][235][236][237][238][239][240][241][242][243][244][245][246][247][248][249][250][251][252][253][254][255] > [0] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [0] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [1] rbuf: (#256): [1][101][201][301][401][501][601][701][801][901][1001][1101][1201][1301][1401][1501][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [1] rcount: (#16): [1][1][1][1][1][1][1][1][1][1][1][1][1][1][1][1] > [1] rdisp: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [1] sbuf: (#256): [100][101][102][103][104][105][106][107][108][109][110][111][112][113][114][115][116][117][118][119][120][121][122][123][124][125][126][127][128][129][130][131][132][133][134][135][136][137][138][139][140][141][142][143][144][145][146][147][148][149][150][151][152][153][154][155][156][157][158][159][160][161][162][163][164][165][166][167][168][169][170][171][172][173][174][175][176][177][178][179][180][181][182][183][184][185][186][187][188][189][190][191][192][193][194][195][196][197][198][199][200][201][202][203][204][205][206][207][208][209][210][211][212][213][214][215][216][217][218][219][220][221][222][223][224][225][226][227][228][229][230][231][232][233][234][235][236][237][238][239][240][241][242][243][244][245][246][247][248][249][250][251][252][253][254][255][256][257][258][259][260][261][262][263][264][265][266][267][268][269][270][271][272][273][274][275][276][277][278][279][280][281][282][283][284][285][286][287][288][289][290][291][292][293][294][295][296][297][298][299][300][301][302][303][304][305][306][307][308][309][310][311][312][313][314][315][316][317][318][319][320][321][322][323][324][325][326][327][328][329][330][331][332][333][334][335][336][337][338][339][340][341][342][343][344][345][346][347][348][349][350][351][352][353][354][355] > [1] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [1] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [2] rbuf: (#256): [3][4][103][104][203][204][303][304][403][404][503][504][603][604][703][704][803][804][903][904][1003][1004][1103][1104][1203][1204][1303][1304][1403][1404][1503][1504][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [2] rcount: (#16): [2][2][2][2][2][2][2][2][2][2][2][2][2][2][2][2] > [2] rdisp: (#16): [0][2][4][6][8][10][12][14][16][18][20][22][24][26][28][30] > [2] sbuf: (#256): [200][201][202][203][204][205][206][207][208][209][210][211][212][213][214][215][216][217][218][219][220][221][222][223][224][225][226][227][228][229][230][231][232][233][234][235][236][237][238][239][240][241][242][243][244][245][246][247][248][249][250][251][252][253][254][255][256][257][258][259][260][261][262][263][264][265][266][267][268][269][270][271][272][273][274][275][276][277][278][279][280][281][282][283][284][285][286][287][288][289][290][291][292][293][294][295][296][297][298][299][300][301][302][303][304][305][306][307][308][309][310][311][312][313][314][315][316][317][318][319][320][321][322][323][324][325][326][327][328][329][330][331][332][333][334][335][336][337][338][339][340][341][342][343][344][345][346][347][348][349][350][351][352][353][354][355][356][357][358][359][360][361][362][363][364][365][366][367][368][369][370][371][372][373][374][375][376][377][378][379][380][381][382][383][384][385][386][387][388][389][390][391][392][393][394][395][396][397][398][399][400][401][402][403][404][405][406][407][408][409][410][411][412][413][414][415][416][417][418][419][420][421][422][423][424][425][426][427][428][429][430][431][432][433][434][435][436][437][438][439][440][441][442][443][444][445][446][447][448][449][450][451][452][453][454][455] > [2] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [2] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [3] rbuf: (#256): [6][7][8][106][107][108][206][207][208][306][307][308][406][407][408][506][507][508][606][607][608][706][707][708][806][807][808][906][907][908][1006][1007][1008][1106][1107][1108][1206][1207][1208][1306][1307][1308][1406][1407][1408][1506][1507][1508][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [3] rcount: (#16): [3][3][3][3][3][3][3][3][3][3][3][3][3][3][3][3] > [3] rdisp: (#16): [0][3][6][9][12][15][18][21][24][27][30][33][36][39][42][45] > [3] sbuf: (#256): [300][301][302][303][304][305][306][307][308][309][310][311][312][313][314][315][316][317][318][319][320][321][322][323][324][325][326][327][328][329][330][331][332][333][334][335][336][337][338][339][340][341][342][343][344][345][346][347][348][349][350][351][352][353][354][355][356][357][358][359][360][361][362][363][364][365][366][367][368][369][370][371][372][373][374][375][376][377][378][379][380][381][382][383][384][385][386][387][388][389][390][391][392][393][394][395][396][397][398][399][400][401][402][403][404][405][406][407][408][409][410][411][412][413][414][415][416][417][418][419][420][421][422][423][424][425][426][427][428][429][430][431][432][433][434][435][436][437][438][439][440][441][442][443][444][445][446][447][448][449][450][451][452][453][454][455][456][457][458][459][460][461][462][463][464][465][466][467][468][469][470][471][472][473][474][475][476][477][478][479][480][481][482][483][484][485][486][487][488][489][490][491][492][493][494][495][496][497][498][499][500][501][502][503][504][505][506][507][508][509][510][511][512][513][514][515][516][517][518][519][520][521][522][523][524][525][526][527][528][529][530][531][532][533][534][535][536][537][538][539][540][541][542][543][544][545][546][547][548][549][550][551][552][553][554][555] > [3] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [3] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [4] rbuf: (#256): [10][11][12][13][110][111][112][113][210][211][212][213][310][311][312][313][410][411][412][413][510][511][512][513][610][611][612][613][710][711][712][713][810][811][812][813][910][911][912][913][1010][1011][1012][1013][1110][1111][1112][1113][1210][1211][1212][1213][1310][1311][1312][1313][1410][1411][1412][1413][1510][1511][1512][1513][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [4] rcount: (#16): [4][4][4][4][4][4][4][4][4][4][4][4][4][4][4][4] > [4] rdisp: (#16): [0][4][8][12][16][20][24][28][32][36][40][44][48][52][56][60] > [4] sbuf: (#256): [400][401][402][403][404][405][406][407][408][409][410][411][412][413][414][415][416][417][418][419][420][421][422][423][424][425][426][427][428][429][430][431][432][433][434][435][436][437][438][439][440][441][442][443][444][445][446][447][448][449][450][451][452][453][454][455][456][457][458][459][460][461][462][463][464][465][466][467][468][469][470][471][472][473][474][475][476][477][478][479][480][481][482][483][484][485][486][487][488][489][490][491][492][493][494][495][496][497][498][499][500][501][502][503][504][505][506][507][508][509][510][511][512][513][514][515][516][517][518][519][520][521][522][523][524][525][526][527][528][529][530][531][532][533][534][535][536][537][538][539][540][541][542][543][544][545][546][547][548][549][550][551][552][553][554][555][556][557][558][559][560][561][562][563][564][565][566][567][568][569][570][571][572][573][574][575][576][577][578][579][580][581][582][583][584][585][586][587][588][589][590][591][592][593][594][595][596][597][598][599][600][601][602][603][604][605][606][607][608][609][610][611][612][613][614][615][616][617][618][619][620][621][622][623][624][625][626][627][628][629][630][631][632][633][634][635][636][637][638][639][640][641][642][643][644][645][646][647][648][649][650][651][652][653][654][655] > [4] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [4] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [5] rbuf: (#256): [15][16][17][18][19][115][116][117][118][119][215][216][217][218][219][315][316][317][318][319][415][416][417][418][419][515][516][517][518][519][615][616][617][618][619][715][716][717][718][719][815][816][817][818][819][915][916][917][918][919][1015][1016][1017][1018][1019][1115][1116][1117][1118][1119][1215][1216][1217][1218][1219][1315][1316][1317][1318][1319][1415][1416][1417][1418][1419][1515][1516][1517][1518][1519][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [5] rcount: (#16): [5][5][5][5][5][5][5][5][5][5][5][5][5][5][5][5] > [5] rdisp: (#16): [0][5][10][15][20][25][30][35][40][45][50][55][60][65][70][75] > [5] sbuf: (#256): [500][501][502][503][504][505][506][507][508][509][510][511][512][513][514][515][516][517][518][519][520][521][522][523][524][525][526][527][528][529][530][531][532][533][534][535][536][537][538][539][540][541][542][543][544][545][546][547][548][549][550][551][552][553][554][555][556][557][558][559][560][561][562][563][564][565][566][567][568][569][570][571][572][573][574][575][576][577][578][579][580][581][582][583][584][585][586][587][588][589][590][591][592][593][594][595][596][597][598][599][600][601][602][603][604][605][606][607][608][609][610][611][612][613][614][615][616][617][618][619][620][621][622][623][624][625][626][627][628][629][630][631][632][633][634][635][636][637][638][639][640][641][642][643][644][645][646][647][648][649][650][651][652][653][654][655][656][657][658][659][660][661][662][663][664][665][666][667][668][669][670][671][672][673][674][675][676][677][678][679][680][681][682][683][684][685][686][687][688][689][690][691][692][693][694][695][696][697][698][699][700][701][702][703][704][705][706][707][708][709][710][711][712][713][714][715][716][717][718][719][720][721][722][723][724][725][726][727][728][729][730][731][732][733][734][735][736][737][738][739][740][741][742][743][744][745][746][747][748][749][750][751][752][753][754][755] > [5] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [5] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [6] rbuf: (#256): [21][22][23][24][25][26][121][122][123][124][125][126][221][222][223][224][225][226][321][322][323][324][325][326][421][422][423][424][425][426][521][522][523][524][525][526][621][622][623][624][625][626][721][722][723][724][725][726][821][822][823][824][825][826][921][922][923][924][925][926][1021][1022][1023][1024][1025][1026][1121][1122][1123][1124][1125][1126][1221][1222][1223][1224][1225][1226][1321][1322][1323][1324][1325][1326][1421][1422][1423][1424][1425][1426][1521][1522][1523][1524][1525][1526][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [6] rcount: (#16): [6][6][6][6][6][6][6][6][6][6][6][6][6][6][6][6] > [6] rdisp: (#16): [0][6][12][18][24][30][36][42][48][54][60][66][72][78][84][90] > [6] sbuf: (#256): [600][601][602][603][604][605][606][607][608][609][610][611][612][613][614][615][616][617][618][619][620][621][622][623][624][625][626][627][628][629][630][631][632][633][634][635][636][637][638][639][640][641][642][643][644][645][646][647][648][649][650][651][652][653][654][655][656][657][658][659][660][661][662][663][664][665][666][667][668][669][670][671][672][673][674][675][676][677][678][679][680][681][682][683][684][685][686][687][688][689][690][691][692][693][694][695][696][697][698][699][700][701][702][703][704][705][706][707][708][709][710][711][712][713][714][715][716][717][718][719][720][721][722][723][724][725][726][727][728][729][730][731][732][733][734][735][736][737][738][739][740][741][742][743][744][745][746][747][748][749][750][751][752][753][754][755][756][757][758][759][760][761][762][763][764][765][766][767][768][769][770][771][772][773][774][775][776][777][778][779][780][781][782][783][784][785][786][787][788][789][790][791][792][793][794][795][796][797][798][799][800][801][802][803][804][805][806][807][808][809][810][811][812][813][814][815][816][817][818][819][820][821][822][823][824][825][826][827][828][829][830][831][832][833][834][835][836][837][838][839][840][841][842][843][844][845][846][847][848][849][850][851][852][853][854][855] > [6] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [6] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [7] rbuf: (#256): [28][29][30][31][32][33][34][128][129][130][131][132][133][134][228][229][230][231][232][233][234][328][329][330][331][332][333][334][428][429][430][431][432][433][434][528][529][530][531][532][533][534][628][629][630][631][632][633][634][728][729][730][731][732][733][734][828][829][830][831][832][833][834][928][929][930][931][932][933][934][1028][1029][1030][1031][1032][1033][1034][1128][1129][1130][1131][1132][1133][1134][1228][1229][1230][1231][1232][1233][1234][1328][1329][1330][1331][1332][1333][1334][1428][1429][1430][1431][1432][1433][1434][1528][1529][1530][1531][1532][1533][1534][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [7] rcount: (#16): [7][7][7][7][7][7][7][7][7][7][7][7][7][7][7][7] > [7] rdisp: (#16): [0][7][14][21][28][35][42][49][56][63][70][77][84][91][98][105] > [7] sbuf: (#256): [700][701][702][703][704][705][706][707][708][709][710][711][712][713][714][715][716][717][718][719][720][721][722][723][724][725][726][727][728][729][730][731][732][733][734][735][736][737][738][739][740][741][742][743][744][745][746][747][748][749][750][751][752][753][754][755][756][757][758][759][760][761][762][763][764][765][766][767][768][769][770][771][772][773][774][775][776][777][778][779][780][781][782][783][784][785][786][787][788][789][790][791][792][793][794][795][796][797][798][799][800][801][802][803][804][805][806][807][808][809][810][811][812][813][814][815][816][817][818][819][820][821][822][823][824][825][826][827][828][829][830][831][832][833][834][835][836][837][838][839][840][841][842][843][844][845][846][847][848][849][850][851][852][853][854][855][856][857][858][859][860][861][862][863][864][865][866][867][868][869][870][871][872][873][874][875][876][877][878][879][880][881][882][883][884][885][886][887][888][889][890][891][892][893][894][895][896][897][898][899][900][901][902][903][904][905][906][907][908][909][910][911][912][913][914][915][916][917][918][919][920][921][922][923][924][925][926][927][928][929][930][931][932][933][934][935][936][937][938][939][940][941][942][943][944][945][946][947][948][949][950][951][952][953][954][955] > [7] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [7] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [8] rbuf: (#256): [36][37][38][39][40][41][42][43][136][137][138][139][140][141][142][143][236][237][238][239][240][241][242][243][336][337][338][339][340][341][342][343][436][437][438][439][440][441][442][443][536][537][538][539][540][541][542][543][636][637][638][639][640][641][642][643][736][737][738][739][740][741][742][743][836][837][838][839][840][841][842][843][936][937][938][939][940][941][942][943][1036][1037][1038][1039][1040][1041][1042][1043][1136][1137][1138][1139][1140][1141][1142][1143][1236][1237][1238][1239][1240][1241][1242][1243][1336][1337][1338][1339][1340][1341][1342][1343][1436][1437][1438][1439][1440][1441][1442][1443][1536][1537][1538][1539][1540][1541][1542][1543][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [8] rcount: (#16): [8][8][8][8][8][8][8][8][8][8][8][8][8][8][8][8] > [8] rdisp: (#16): [0][8][16][24][32][40][48][56][64][72][80][88][96][104][112][120] > [8] sbuf: (#256): [800][801][802][803][804][805][806][807][808][809][810][811][812][813][814][815][816][817][818][819][820][821][822][823][824][825][826][827][828][829][830][831][832][833][834][835][836][837][838][839][840][841][842][843][844][845][846][847][848][849][850][851][852][853][854][855][856][857][858][859][860][861][862][863][864][865][866][867][868][869][870][871][872][873][874][875][876][877][878][879][880][881][882][883][884][885][886][887][888][889][890][891][892][893][894][895][896][897][898][899][900][901][902][903][904][905][906][907][908][909][910][911][912][913][914][915][916][917][918][919][920][921][922][923][924][925][926][927][928][929][930][931][932][933][934][935][936][937][938][939][940][941][942][943][944][945][946][947][948][949][950][951][952][953][954][955][956][957][958][959][960][961][962][963][964][965][966][967][968][969][970][971][972][973][974][975][976][977][978][979][980][981][982][983][984][985][986][987][988][989][990][991][992][993][994][995][996][997][998][999][1000][1001][1002][1003][1004][1005][1006][1007][1008][1009][1010][1011][1012][1013][1014][1015][1016][1017][1018][1019][1020][1021][1022][1023][1024][1025][1026][1027][1028][1029][1030][1031][1032][1033][1034][1035][1036][1037][1038][1039][1040][1041][1042][1043][1044][1045][1046][1047][1048][1049][1050][1051][1052][1053][1054][1055] > [8] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [8] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [9] rbuf: (#256): [45][46][47][48][49][50][51][52][53][145][146][147][148][149][150][151][152][153][245][246][247][248][249][250][251][252][253][345][346][347][348][349][350][351][352][353][445][446][447][448][449][450][451][452][453][545][546][547][548][549][550][551][552][553][645][646][647][648][649][650][651][652][653][745][746][747][748][749][750][751][752][753][845][846][847][848][849][850][851][852][853][945][946][947][948][949][950][951][952][953][1045][1046][1047][1048][1049][1050][1051][1052][1053][1145][1146][1147][1148][1149][1150][1151][1152][1153][1245][1246][1247][1248][1249][1250][1251][1252][1253][1345][1346][1347][1348][1349][1350][1351][1352][1353][1445][1446][1447][1448][1449][1450][1451][1452][1453][1545][1546][1547][1548][1549][1550][1551][1552][1553][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [9] rcount: (#16): [9][9][9][9][9][9][9][9][9][9][9][9][9][9][9][9] > [9] rdisp: (#16): [0][9][18][27][36][45][54][63][72][81][90][99][108][117][126][135] > [9] sbuf: (#256): [900][901][902][903][904][905][906][907][908][909][910][911][912][913][914][915][916][917][918][919][920][921][922][923][924][925][926][927][928][929][930][931][932][933][934][935][936][937][938][939][940][941][942][943][944][945][946][947][948][949][950][951][952][953][954][955][956][957][958][959][960][961][962][963][964][965][966][967][968][969][970][971][972][973][974][975][976][977][978][979][980][981][982][983][984][985][986][987][988][989][990][991][992][993][994][995][996][997][998][999][1000][1001][1002][1003][1004][1005][1006][1007][1008][1009][1010][1011][1012][1013][1014][1015][1016][1017][1018][1019][1020][1021][1022][1023][1024][1025][1026][1027][1028][1029][1030][1031][1032][1033][1034][1035][1036][1037][1038][1039][1040][1041][1042][1043][1044][1045][1046][1047][1048][1049][1050][1051][1052][1053][1054][1055][1056][1057][1058][1059][1060][1061][1062][1063][1064][1065][1066][1067][1068][1069][1070][1071][1072][1073][1074][1075][1076][1077][1078][1079][1080][1081][1082][1083][1084][1085][1086][1087][1088][1089][1090][1091][1092][1093][1094][1095][1096][1097][1098][1099][1100][1101][1102][1103][1104][1105][1106][1107][1108][1109][1110][1111][1112][1113][1114][1115][1116][1117][1118][1119][1120][1121][1122][1123][1124][1125][1126][1127][1128][1129][1130][1131][1132][1133][1134][1135][1136][1137][1138][1139][1140][1141][1142][1143][1144][1145][1146][1147][1148][1149][1150][1151][1152][1153][1154][1155] > [9] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [9] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [10] rbuf: (#256): [55][56][57][58][59][60][61][62][63][64][155][156][157][158][159][160][161][162][163][164][255][256][257][258][259][260][261][262][263][264][355][356][357][358][359][360][361][362][363][364][455][456][457][458][459][460][461][462][463][464][555][556][557][558][559][560][561][562][563][564][655][656][657][658][659][660][661][662][663][664][755][756][757][758][759][760][761][762][763][764][855][856][857][858][859][860][861][862][863][864][955][956][957][958][959][960][961][962][963][964][1055][1056][1057][1058][1059][1060][1061][1062][1063][1064][1155][1156][1157][1158][1159][1160][1161][1162][1163][1164][1255][1256][1257][1258][1259][1260][1261][1262][1263][1264][1355][1356][1357][1358][1359][1360][1361][1362][1363][1364][1455][1456][1457][1458][1459][1460][1461][1462][1463][1464][1555][1556][1557][1558][1559][1560][1561][1562][1563][1564][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [10] rcount: (#16): [10][10][10][10][10][10][10][10][10][10][10][10][10][10][10][10] > [10] rdisp: (#16): [0][10][20][30][40][50][60][70][80][90][100][110][120][130][140][150] > [10] sbuf: (#256): [1000][1001][1002][1003][1004][1005][1006][1007][1008][1009][1010][1011][1012][1013][1014][1015][1016][1017][1018][1019][1020][1021][1022][1023][1024][1025][1026][1027][1028][1029][1030][1031][1032][1033][1034][1035][1036][1037][1038][1039][1040][1041][1042][1043][1044][1045][1046][1047][1048][1049][1050][1051][1052][1053][1054][1055][1056][1057][1058][1059][1060][1061][1062][1063][1064][1065][1066][1067][1068][1069][1070][1071][1072][1073][1074][1075][1076][1077][1078][1079][1080][1081][1082][1083][1084][1085][1086][1087][1088][1089][1090][1091][1092][1093][1094][1095][1096][1097][1098][1099][1100][1101][1102][1103][1104][1105][1106][1107][1108][1109][1110][1111][1112][1113][1114][1115][1116][1117][1118][1119][1120][1121][1122][1123][1124][1125][1126][1127][1128][1129][1130][1131][1132][1133][1134][1135][1136][1137][1138][1139][1140][1141][1142][1143][1144][1145][1146][1147][1148][1149][1150][1151][1152][1153][1154][1155][1156][1157][1158][1159][1160][1161][1162][1163][1164][1165][1166][1167][1168][1169][1170][1171][1172][1173][1174][1175][1176][1177][1178][1179][1180][1181][1182][1183][1184][1185][1186][1187][1188][1189][1190][1191][1192][1193][1194][1195][1196][1197][1198][1199][1200][1201][1202][1203][1204][1205][1206][1207][1208][1209][1210][1211][1212][1213][1214][1215][1216][1217][1218][1219][1220][1221][1222][1223][1224][1225][1226][1227][1228][1229][1230][1231][1232][1233][1234][1235][1236][1237][1238][1239][1240][1241][1242][1243][1244][1245][1246][1247][1248][1249][1250][1251][1252][1253][1254][1255] > [10] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [10] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [11] rbuf: (#256): [66][67][68][69][70][71][72][73][74][75][76][166][167][168][169][170][171][172][173][174][175][176][266][267][268][269][270][271][272][273][274][275][276][366][367][368][369][370][371][372][373][374][375][376][466][467][468][469][470][471][472][473][474][475][476][566][567][568][569][570][571][572][573][574][575][576][666][667][668][669][670][671][672][673][674][675][676][766][767][768][769][770][771][772][773][774][775][776][866][867][868][869][870][871][872][873][874][875][876][966][967][968][969][970][971][972][973][974][975][976][1066][1067][1068][1069][1070][1071][1072][1073][1074][1075][1076][1166][1167][1168][1169][1170][1171][1172][1173][1174][1175][1176][1266][1267][1268][1269][1270][1271][1272][1273][1274][1275][1276][1366][1367][1368][1369][1370][1371][1372][1373][1374][1375][1376][1466][1467][1468][1469][1470][1471][1472][1473][1474][1475][1476][1566][1567][1568][1569][1570][1571][1572][1573][1574][1575][1576][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [11] rcount: (#16): [11][11][11][11][11][11][11][11][11][11][11][11][11][11][11][11] > [11] rdisp: (#16): [0][11][22][33][44][55][66][77][88][99][110][121][132][143][154][165] > [11] sbuf: (#256): [1100][1101][1102][1103][1104][1105][1106][1107][1108][1109][1110][1111][1112][1113][1114][1115][1116][1117][1118][1119][1120][1121][1122][1123][1124][1125][1126][1127][1128][1129][1130][1131][1132][1133][1134][1135][1136][1137][1138][1139][1140][1141][1142][1143][1144][1145][1146][1147][1148][1149][1150][1151][1152][1153][1154][1155][1156][1157][1158][1159][1160][1161][1162][1163][1164][1165][1166][1167][1168][1169][1170][1171][1172][1173][1174][1175][1176][1177][1178][1179][1180][1181][1182][1183][1184][1185][1186][1187][1188][1189][1190][1191][1192][1193][1194][1195][1196][1197][1198][1199][1200][1201][1202][1203][1204][1205][1206][1207][1208][1209][1210][1211][1212][1213][1214][1215][1216][1217][1218][1219][1220][1221][1222][1223][1224][1225][1226][1227][1228][1229][1230][1231][1232][1233][1234][1235][1236][1237][1238][1239][1240][1241][1242][1243][1244][1245][1246][1247][1248][1249][1250][1251][1252][1253][1254][1255][1256][1257][1258][1259][1260][1261][1262][1263][1264][1265][1266][1267][1268][1269][1270][1271][1272][1273][1274][1275][1276][1277][1278][1279][1280][1281][1282][1283][1284][1285][1286][1287][1288][1289][1290][1291][1292][1293][1294][1295][1296][1297][1298][1299][1300][1301][1302][1303][1304][1305][1306][1307][1308][1309][1310][1311][1312][1313][1314][1315][1316][1317][1318][1319][1320][1321][1322][1323][1324][1325][1326][1327][1328][1329][1330][1331][1332][1333][1334][1335][1336][1337][1338][1339][1340][1341][1342][1343][1344][1345][1346][1347][1348][1349][1350][1351][1352][1353][1354][1355] > [11] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [11] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [12] rbuf: (#256): [78][79][80][81][82][83][84][85][86][87][88][89][178][179][180][181][182][183][184][185][186][187][188][189][278][279][280][281][282][283][284][285][286][287][288][289][378][379][380][381][382][383][384][385][386][387][388][389][478][479][480][481][482][483][484][485][486][487][488][489][578][579][580][581][582][583][584][585][586][587][588][589][678][679][680][681][682][683][684][685][686][687][688][689][778][779][780][781][782][783][784][785][786][787][788][789][878][879][880][881][882][883][884][885][886][887][888][889][978][979][980][981][982][983][984][985][986][987][988][989][1078][1079][1080][1081][1082][1083][1084][1085][1086][1087][1088][1089][1178][1179][1180][1181][1182][1183][1184][1185][1186][1187][1188][1189][1278][1279][1280][1281][1282][1283][1284][1285][1286][1287][1288][1289][1378][1379][1380][1381][1382][1383][1384][1385][1386][1387][1388][1389][1478][1479][1480][1481][1482][1483][1484][1485][1486][1487][1488][1489][1578][1579][1580][1581][1582][1583][1584][1585][1586][1587][1588][1589][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [12] rcount: (#16): [12][12][12][12][12][12][12][12][12][12][12][12][12][12][12][12] > [12] rdisp: (#16): [0][12][24][36][48][60][72][84][96][108][120][132][144][156][168][180] > [12] sbuf: (#256): [1200][1201][1202][1203][1204][1205][1206][1207][1208][1209][1210][1211][1212][1213][1214][1215][1216][1217][1218][1219][1220][1221][1222][1223][1224][1225][1226][1227][1228][1229][1230][1231][1232][1233][1234][1235][1236][1237][1238][1239][1240][1241][1242][1243][1244][1245][1246][1247][1248][1249][1250][1251][1252][1253][1254][1255][1256][1257][1258][1259][1260][1261][1262][1263][1264][1265][1266][1267][1268][1269][1270][1271][1272][1273][1274][1275][1276][1277][1278][1279][1280][1281][1282][1283][1284][1285][1286][1287][1288][1289][1290][1291][1292][1293][1294][1295][1296][1297][1298][1299][1300][1301][1302][1303][1304][1305][1306][1307][1308][1309][1310][1311][1312][1313][1314][1315][1316][1317][1318][1319][1320][1321][1322][1323][1324][1325][1326][1327][1328][1329][1330][1331][1332][1333][1334][1335][1336][1337][1338][1339][1340][1341][1342][1343][1344][1345][1346][1347][1348][1349][1350][1351][1352][1353][1354][1355][1356][1357][1358][1359][1360][1361][1362][1363][1364][1365][1366][1367][1368][1369][1370][1371][1372][1373][1374][1375][1376][1377][1378][1379][1380][1381][1382][1383][1384][1385][1386][1387][1388][1389][1390][1391][1392][1393][1394][1395][1396][1397][1398][1399][1400][1401][1402][1403][1404][1405][1406][1407][1408][1409][1410][1411][1412][1413][1414][1415][1416][1417][1418][1419][1420][1421][1422][1423][1424][1425][1426][1427][1428][1429][1430][1431][1432][1433][1434][1435][1436][1437][1438][1439][1440][1441][1442][1443][1444][1445][1446][1447][1448][1449][1450][1451][1452][1453][1454][1455] > [12] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [12] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [13] rbuf: (#256): [91][92][93][94][95][96][97][98][99][100][101][102][103][191][192][193][194][195][196][197][198][199][200][201][202][203][291][292][293][294][295][296][297][298][299][300][301][302][303][391][392][393][394][395][396][397][398][399][400][401][402][403][491][492][493][494][495][496][497][498][499][500][501][502][503][591][592][593][594][595][596][597][598][599][600][601][602][603][691][692][693][694][695][696][697][698][699][700][701][702][703][791][792][793][794][795][796][797][798][799][800][801][802][803][891][892][893][894][895][896][897][898][899][900][901][902][903][991][992][993][994][995][996][997][998][999][1000][1001][1002][1003][1091][1092][1093][1094][1095][1096][1097][1098][1099][1100][1101][1102][1103][1191][1192][1193][1194][1195][1196][1197][1198][1199][1200][1201][1202][1203][1291][1292][1293][1294][1295][1296][1297][1298][1299][1300][1301][1302][1303][1391][1392][1393][1394][1395][1396][1397][1398][1399][1400][1401][1402][1403][1491][1492][1493][1494][1495][1496][1497][1498][1499][1500][1501][1502][1503][1591][1592][1593][1594][1595][1596][1597][1598][1599][1600][1601][1602][1603][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [13] rcount: (#16): [13][13][13][13][13][13][13][13][13][13][13][13][13][13][13][13] > [13] rdisp: (#16): [0][13][26][39][52][65][78][91][104][117][130][143][156][169][182][195] > [13] sbuf: (#256): [1300][1301][1302][1303][1304][1305][1306][1307][1308][1309][1310][1311][1312][1313][1314][1315][1316][1317][1318][1319][1320][1321][1322][1323][1324][1325][1326][1327][1328][1329][1330][1331][1332][1333][1334][1335][1336][1337][1338][1339][1340][1341][1342][1343][1344][1345][1346][1347][1348][1349][1350][1351][1352][1353][1354][1355][1356][1357][1358][1359][1360][1361][1362][1363][1364][1365][1366][1367][1368][1369][1370][1371][1372][1373][1374][1375][1376][1377][1378][1379][1380][1381][1382][1383][1384][1385][1386][1387][1388][1389][1390][1391][1392][1393][1394][1395][1396][1397][1398][1399][1400][1401][1402][1403][1404][1405][1406][1407][1408][1409][1410][1411][1412][1413][1414][1415][1416][1417][1418][1419][1420][1421][1422][1423][1424][1425][1426][1427][1428][1429][1430][1431][1432][1433][1434][1435][1436][1437][1438][1439][1440][1441][1442][1443][1444][1445][1446][1447][1448][1449][1450][1451][1452][1453][1454][1455][1456][1457][1458][1459][1460][1461][1462][1463][1464][1465][1466][1467][1468][1469][1470][1471][1472][1473][1474][1475][1476][1477][1478][1479][1480][1481][1482][1483][1484][1485][1486][1487][1488][1489][1490][1491][1492][1493][1494][1495][1496][1497][1498][1499][1500][1501][1502][1503][1504][1505][1506][1507][1508][1509][1510][1511][1512][1513][1514][1515][1516][1517][1518][1519][1520][1521][1522][1523][1524][1525][1526][1527][1528][1529][1530][1531][1532][1533][1534][1535][1536][1537][1538][1539][1540][1541][1542][1543][1544][1545][1546][1547][1548][1549][1550][1551][1552][1553][1554][1555] > [13] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [13] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [14] rbuf: (#256): [105][106][107][108][109][110][111][112][113][114][115][116][117][118][205][206][207][208][209][210][211][212][213][214][215][216][217][218][305][306][307][308][309][310][311][312][313][314][315][316][317][318][405][406][407][408][409][410][411][412][413][414][415][416][417][418][505][506][507][508][509][510][511][512][513][514][515][516][517][518][605][606][607][608][609][610][611][612][613][614][615][616][617][618][705][706][707][708][709][710][711][712][713][714][715][716][717][718][805][806][807][808][809][810][811][812][813][814][815][816][817][818][905][906][907][908][909][910][911][912][913][914][915][916][917][918][1005][1006][1007][1008][1009][1010][1011][1012][1013][1014][1015][1016][1017][1018][1105][1106][1107][1108][1109][1110][1111][1112][1113][1114][1115][1116][1117][1118][1205][1206][1207][1208][1209][1210][1211][1212][1213][1214][1215][1216][1217][1218][1305][1306][1307][1308][1309][1310][1311][1312][1313][1314][1315][1316][1317][1318][1405][1406][1407][1408][1409][1410][1411][1412][1413][1414][1415][1416][1417][1418][1505][1506][1507][1508][1509][1510][1511][1512][1513][1514][1515][1516][1517][1518][1605][1606][1607][1608][1609][1610][1611][1612][1613][1614][1615][1616][1617][1618][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [14] rcount: (#16): [14][14][14][14][14][14][14][14][14][14][14][14][14][14][14][14] > [14] rdisp: (#16): [0][14][28][42][56][70][84][98][112][126][140][154][168][182][196][210] > [14] sbuf: (#256): [1400][1401][1402][1403][1404][1405][1406][1407][1408][1409][1410][1411][1412][1413][1414][1415][1416][1417][1418][1419][1420][1421][1422][1423][1424][1425][1426][1427][1428][1429][1430][1431][1432][1433][1434][1435][1436][1437][1438][1439][1440][1441][1442][1443][1444][1445][1446][1447][1448][1449][1450][1451][1452][1453][1454][1455][1456][1457][1458][1459][1460][1461][1462][1463][1464][1465][1466][1467][1468][1469][1470][1471][1472][1473][1474][1475][1476][1477][1478][1479][1480][1481][1482][1483][1484][1485][1486][1487][1488][1489][1490][1491][1492][1493][1494][1495][1496][1497][1498][1499][1500][1501][1502][1503][1504][1505][1506][1507][1508][1509][1510][1511][1512][1513][1514][1515][1516][1517][1518][1519][1520][1521][1522][1523][1524][1525][1526][1527][1528][1529][1530][1531][1532][1533][1534][1535][1536][1537][1538][1539][1540][1541][1542][1543][1544][1545][1546][1547][1548][1549][1550][1551][1552][1553][1554][1555][1556][1557][1558][1559][1560][1561][1562][1563][1564][1565][1566][1567][1568][1569][1570][1571][1572][1573][1574][1575][1576][1577][1578][1579][1580][1581][1582][1583][1584][1585][1586][1587][1588][1589][1590][1591][1592][1593][1594][1595][1596][1597][1598][1599][1600][1601][1602][1603][1604][1605][1606][1607][1608][1609][1610][1611][1612][1613][1614][1615][1616][1617][1618][1619][1620][1621][1622][1623][1624][1625][1626][1627][1628][1629][1630][1631][1632][1633][1634][1635][1636][1637][1638][1639][1640][1641][1642][1643][1644][1645][1646][1647][1648][1649][1650][1651][1652][1653][1654][1655] > [14] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [14] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > [15] rbuf: (#256): [120][121][122][123][124][125][126][127][128][129][130][131][132][133][134][220][221][222][223][224][225][226][227][228][229][230][231][232][233][234][320][321][322][323][324][325][326][327][328][329][330][331][332][333][334][420][421][422][423][424][425][426][427][428][429][430][431][432][433][434][520][521][522][523][524][525][526][527][528][529][530][531][532][533][534][620][621][622][623][624][625][626][627][628][629][630][631][632][633][634][720][721][722][723][724][725][726][727][728][729][730][731][732][733][734][820][821][822][823][824][825][826][827][828][829][830][831][832][833][834][920][921][922][923][924][925][926][927][928][929][930][931][932][933][934][1020][1021][1022][1023][1024][1025][1026][1027][1028][1029][1030][1031][1032][1033][1034][1120][1121][1122][1123][1124][1125][1126][1127][1128][1129][1130][1131][1132][1133][1134][1220][1221][1222][1223][1224][1225][1226][1227][1228][1229][1230][1231][1232][1233][1234][1320][1321][1322][1323][1324][1325][1326][1327][1328][1329][1330][1331][1332][1333][1334][1420][1421][1422][1423][1424][1425][1426][1427][1428][1429][1430][1431][1432][1433][1434][1520][1521][1522][1523][1524][1525][1526][1527][1528][1529][1530][1531][1532][1533][1534][1620][1621][1622][1623][1624][1625][1626][1627][1628][1629][1630][1631][1632][1633][1634][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1][-1] > [15] rcount: (#16): [15][15][15][15][15][15][15][15][15][15][15][15][15][15][15][15] > [15] rdisp: (#16): [0][15][30][45][60][75][90][105][120][135][150][165][180][195][210][225] > [15] sbuf: (#256): [1500][1501][1502][1503][1504][1505][1506][1507][1508][1509][1510][1511][1512][1513][1514][1515][1516][1517][1518][1519][1520][1521][1522][1523][1524][1525][1526][1527][1528][1529][1530][1531][1532][1533][1534][1535][1536][1537][1538][1539][1540][1541][1542][1543][1544][1545][1546][1547][1548][1549][1550][1551][1552][1553][1554][1555][1556][1557][1558][1559][1560][1561][1562][1563][1564][1565][1566][1567][1568][1569][1570][1571][1572][1573][1574][1575][1576][1577][1578][1579][1580][1581][1582][1583][1584][1585][1586][1587][1588][1589][1590][1591][1592][1593][1594][1595][1596][1597][1598][1599][1600][1601][1602][1603][1604][1605][1606][1607][1608][1609][1610][1611][1612][1613][1614][1615][1616][1617][1618][1619][1620][1621][1622][1623][1624][1625][1626][1627][1628][1629][1630][1631][1632][1633][1634][1635][1636][1637][1638][1639][1640][1641][1642][1643][1644][1645][1646][1647][1648][1649][1650][1651][1652][1653][1654][1655][1656][1657][1658][1659][1660][1661][1662][1663][1664][1665][1666][1667][1668][1669][1670][1671][1672][1673][1674][1675][1676][1677][1678][1679][1680][1681][1682][1683][1684][1685][1686][1687][1688][1689][1690][1691][1692][1693][1694][1695][1696][1697][1698][1699][1700][1701][1702][1703][1704][1705][1706][1707][1708][1709][1710][1711][1712][1713][1714][1715][1716][1717][1718][1719][1720][1721][1722][1723][1724][1725][1726][1727][1728][1729][1730][1731][1732][1733][1734][1735][1736][1737][1738][1739][1740][1741][1742][1743][1744][1745][1746][1747][1748][1749][1750][1751][1752][1753][1754][1755] > [15] scount: (#16): [0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15] > [15] sdisp: (#16): [0][1][3][6][10][15][21][28][36][45][55][66][78][91][105][120] > > Alltoallv TEST COMPLETE. SimGrid-3.11/teshsuite/smpi/alltoallv/CMakeLists.txt000644 001750 001750 00000001460 12342443654 021553 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(alltoallv_coll alltoallv_coll.c) target_link_libraries(alltoallv_coll simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/alltoallv_coll.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/alltoallv_coll.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/reduce/000755 001750 001750 00000000000 12342443665 016271 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/reduce/reduce_coll.tesh000644 001750 001750 00000005052 12342443665 021440 0ustar00cici000000 000000 # Smpi Allreduce collectives tests ! setenv LD_LIBRARY_PATH=../../lib ! output sort p Test allreduce $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 16 --log=xbt_cfg.thres:critical ${bindir:=.}/reduce_coll --log=smpi_kernel.thres:warning > You requested to use 16 processes, but there is only 5 processes in your hostfile... > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0] rcvbuf=[1920 1936 1952 1968 1984 2000 2016 2032 2048 2064 2080 2096 2112 2128 2144 2160 ] > [0] second sndbuf=[0 ] > [0] sndbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ] > [10] second sndbuf=[160 ] > [10] sndbuf=[160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 ] > [11] second sndbuf=[176 ] > [11] sndbuf=[176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 ] > [12] second sndbuf=[192 ] > [12] sndbuf=[192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 ] > [13] second sndbuf=[208 ] > [13] sndbuf=[208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 ] > [14] second sndbuf=[224 ] > [14] sndbuf=[224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 ] > [15] rcvbuf=[0 ] > [15] second sndbuf=[240 ] > [15] sndbuf=[240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 ] > [1] second sndbuf=[16 ] > [1] sndbuf=[16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [2] second sndbuf=[32 ] > [2] sndbuf=[32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 ] > [3] second sndbuf=[48 ] > [3] sndbuf=[48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 ] > [4] second sndbuf=[64 ] > [4] sndbuf=[64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 ] > [5] second sndbuf=[80 ] > [5] sndbuf=[80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 ] > [6] second sndbuf=[96 ] > [6] sndbuf=[96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 ] > [7] second sndbuf=[112 ] > [7] sndbuf=[112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 ] > [8] second sndbuf=[128 ] > [8] sndbuf=[128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 ] > [9] second sndbuf=[144 ] > [9] sndbuf=[144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 ] > [rank 0] -> Tremblay > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [rank 12] -> Fafard > [rank 13] -> Ginette > [rank 14] -> Bourassa > [rank 15] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa SimGrid-3.11/teshsuite/smpi/reduce/reduce.c000644 001750 001750 00000007357 12342443660 017713 0ustar00cici000000 000000 /* Copyright (c) 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include /** * MESSAGE PASSING INTERFACE TEST CASE SUITE * * Copyright IBM Corp. 1995 * * IBM Corp. hereby grants a non-exclusive license to use, copy, modify, and *distribute this software for any purpose and without fee provided that the *above copyright notice and the following paragraphs appear in all copies. * IBM Corp. makes no representation that the test cases comprising this * suite are correct or are an accurate representation of any standard. * In no event shall IBM be liable to any party for direct, indirect, special * incidental, or consequential damage arising out of the use of this software * even if IBM Corp. has been advised of the possibility of such damage. * IBM CORP. SPECIFICALLY DISCLAIMS ANY WARRANTIES INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS AND IBM * CORP. HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, * ENHANCEMENTS, OR MODIFICATIONS. * *************************************************************************** **/ static int ibm_test(int rank, int size) { int success = 1; #define MAXLEN 10000 int root, i, j, k; int out[MAXLEN]; int in[MAXLEN]; root = size / 2; for (j = 1; j <= MAXLEN; j *= 10) { for (i = 0; i < j; i++) out[i] = i; MPI_Reduce(out, in, j, MPI_INT, MPI_SUM, root, MPI_COMM_WORLD); if (rank == root) { for (k = 0; k < j; k++) { if (in[k] != k * size) { printf("bad answer (%d) at index %d of %d (should be %d)", in[k], k, j, k * size); success = 0; break; } } } } return (success); } int main(int argc, char **argv) { int size, rank; int root = 0; int value; int sum = -99, sum_mirror = -99, min = 999, max = -999; double start_timer; int quiet = 0; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (argc > 1 && !strcmp(argv[1], "-q")) quiet = 1; start_timer = MPI_Wtime(); value = rank + 1; /* easy to verify that sum= (size*(size+1))/2; */ //printf("[%d] has value %d\n", rank, value); MPI_Reduce(&value, &sum, 1, MPI_INT, MPI_SUM, root, MPI_COMM_WORLD); MPI_Reduce(&value, &sum_mirror, 1, MPI_INT, MPI_SUM, root, MPI_COMM_WORLD); MPI_Reduce(&value, &min, 1, MPI_INT, MPI_MIN, root, MPI_COMM_WORLD); MPI_Reduce(&value, &max, 1, MPI_INT, MPI_MAX, root, MPI_COMM_WORLD); if (rank == root) { printf("** Scalar Int Test Result:\n"); printf("\t[%d] sum=%d ... validation ", rank, sum); if (((size * (size + 1)) / 2 == sum) && (sum_mirror == sum)) printf("ok.\n"); else printf("failed (sum=%d,sum_mirror=%d while both sould be %d.\n", sum, sum_mirror, (size * (size + 1)) / 2); printf("\t[%d] min=%d ... validation ", rank, min); if (1 == min) printf("ok.\n"); else printf("failed.\n"); printf("\t[%d] max=%d ... validation ", rank, max); if (size == max) printf("ok.\n"); else printf("failed.\n"); if (!quiet) printf("Elapsed time=%f s\n", MPI_Wtime() - start_timer); } MPI_Barrier(MPI_COMM_WORLD); if (0 == rank) printf("** IBM Test Result: ...\n"); if (!ibm_test(rank, size)) printf("\t[%d] failed.\n", rank); else if (!quiet) printf("\t[%d] ok.\n", rank); else printf("\tok.\n"); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/reduce/reduce_scatter_coll.tesh000644 001750 001750 00000001617 12342443665 023170 0ustar00cici000000 000000 # Smpi reduce scatter collectives tests ! setenv LD_LIBRARY_PATH=../../lib ! output sort p Test reduce_scatter $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 16 --log=xbt_cfg.thres:critical ${bindir:=.}/reduce_scatter_coll --log=smpi_kernel.thres:warning > No Errors > You requested to use 16 processes, but there is only 5 processes in your hostfile... > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [rank 0] -> Tremblay > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [rank 12] -> Fafard > [rank 13] -> Ginette > [rank 14] -> Bourassa > [rank 15] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa SimGrid-3.11/teshsuite/smpi/reduce/reduce_scatter_coll.c000644 001750 001750 00000003241 12342443660 022435 0ustar00cici000000 000000 /* Copyright (c) 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /* * Test of reduce scatter. * * Each processor contributes its rank + the index to the reduction, * then receives the ith sum * * Can be called with any number of processors. */ #include "mpi.h" #include #include int main( int argc, char **argv ) { int err = 0, toterr; int *sendbuf, *recvbuf, *recvcounts; int size, rank, i, sumval; MPI_Comm comm; MPI_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); sendbuf = (int *) malloc( size * sizeof(int) ); for (i=0; i #include #include #include #include "mpi.h" #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #define EXIT_FAILURE 1 #endif int main(int argc, char *argv[]) { int rank, size; int i; int *sb; int *rb; int status; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); sb = (int *) xbt_malloc(size * sizeof(int)); rb = (int *) xbt_malloc(size * sizeof(int)); for (i = 0; i < size; ++i) { sb[i] = rank*size + i; rb[i] = 0; } printf("[%d] sndbuf=[", rank); for (i = 0; i < size; i++) printf("%d ", sb[i]); printf("]\n"); int root=0; status = MPI_Reduce(sb, rb, size, MPI_INT, MPI_SUM, root, MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); if (rank == root) { printf("[%d] rcvbuf=[", rank); for (i = 0; i < size; i++) printf("%d ", rb[i]); printf("]\n"); if (status != MPI_SUCCESS) { printf("all_to_all returned %d\n", status); fflush(stdout); } } printf("[%d] second sndbuf=[", rank); for (i = 0; i < 1; i++) printf("%d ", sb[i]); printf("]\n"); root=size-1; status = MPI_Reduce(sb, rb, 1, MPI_INT, MPI_PROD, root, MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); if (rank == root) { printf("[%d] rcvbuf=[", rank); for (i = 0; i < 1; i++) printf("%d ", rb[i]); printf("]\n"); if (status != MPI_SUCCESS) { printf("all_to_all returned %d\n", status); fflush(stdout); } } free(sb); free(rb); MPI_Finalize(); return (EXIT_SUCCESS); } SimGrid-3.11/teshsuite/smpi/reduce/reduce.tesh000644 001750 001750 00000006517 12342443665 020436 0ustar00cici000000 000000 # use the tested library, not the installed one # (since we want to pass it to the child, it has to be redefined before each command) # Go for the first test p Test Reduce with 3 processes ! output sort $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 3 ${bindir:=.}/reduce -q --log=smpi_kernel.thres:warning > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > ** Scalar Int Test Result: > [0] sum=6 ... validation ok. > [0] min=1 ... validation ok. > [0] max=3 ... validation ok. > ** IBM Test Result: ... > ok. > ok. > ok. # second test ! setenv LD_LIBRARY_PATH=../../lib ! output sort p Test Reduce with 5 processes $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 5 ${bindir:=.}/reduce -q --log=smpi_kernel.thres:warning > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > ** Scalar Int Test Result: > [0] sum=15 ... validation ok. > [0] min=1 ... validation ok. > [0] max=5 ... validation ok. > ** IBM Test Result: ... > ok. > ok. > ok. > ok. > ok. # third test ! output sort ! setenv LD_LIBRARY_PATH=../../lib p Test Reduce with 12 processes $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 12 ${bindir:=.}/reduce -q --log=smpi_kernel.thres:warning > You requested to use 12 processes, but there is only 5 processes in your hostfile... > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > ** Scalar Int Test Result: > [0] sum=78 ... validation ok. > [0] min=1 ... validation ok. > [0] max=12 ... validation ok. > ** IBM Test Result: ... > ok. > ok. > ok. > ok. > ok. > ok. > ok. > ok. > ok. > ok. > ok. > ok. SimGrid-3.11/teshsuite/smpi/reduce/CMakeLists.txt000644 001750 001750 00000002230 12342443654 021024 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(reduce reduce.c) add_executable(reduce_coll reduce_coll.c) add_executable(reduce_scatter_coll reduce_scatter_coll.c) target_link_libraries(reduce simgrid) target_link_libraries(reduce_coll simgrid) target_link_libraries(reduce_scatter_coll simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/reduce.tesh ${CMAKE_CURRENT_SOURCE_DIR}/reduce_coll.tesh ${CMAKE_CURRENT_SOURCE_DIR}/reduce_scatter_coll.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/reduce.c ${CMAKE_CURRENT_SOURCE_DIR}/reduce_coll.c ${CMAKE_CURRENT_SOURCE_DIR}/reduce_scatter_coll.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/shared/000755 001750 001750 00000000000 12342443665 016270 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/shared/shared.c000644 001750 001750 00000003132 12342443660 017674 0ustar00cici000000 000000 /* Copyright (c) 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /* This example should be instructive to learn about SMPI_SAMPLE_LOCAL and SMPI_SAMPLE_GLOBAL macros for execution sampling */ #include #include #include #include void* hash(char *str, uint64_t* ans); void* hash(char *str, uint64_t* ans) { *ans=5381; int c; printf("hashing !\n"); while ((c = *str++)!=0) *ans = ((*ans << 5) + *ans) + c; /* hash * 33 + c */ return NULL; } int main(int argc, char *argv[]) { MPI_Init(&argc, &argv); int rank, size; MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); //Let's Allocate a shared memory buffer uint64_t* buf = SMPI_SHARED_MALLOC(sizeof(uint64_t)); //one writes data in it if(rank==0){ *buf=size; } MPI_Barrier(MPI_COMM_WORLD); //everyobne reads from it. printf("[%d] The value in the shared buffer is: %" PRIu64"\n", rank, *buf); MPI_Barrier(MPI_COMM_WORLD); //Try SMPI_SHARED_CALL function, which should call hash only once and for all. char *str = strdup("onceandforall"); if(rank==size-1){ SMPI_SHARED_CALL(hash,str,str,buf); } MPI_Barrier(MPI_COMM_WORLD); printf("[%d] After change, the value in the shared buffer is: %" PRIu64"\n", rank, *buf); SMPI_SHARED_FREE(buf); buf=NULL; free(str); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/shared/shared.tesh000644 001750 001750 00000002242 12342443665 020423 0ustar00cici000000 000000 p Test compute ! setenv LD_LIBRARY_PATH=../../lib ! output sort ! timeout 5 $ ${bindir:=.}/../../../bin/smpirun -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 4 ${bindir:=.}/shared --log=smpi_kernel.thres:warning > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0] After change, the value in the shared buffer is: 16053117601147974045 > [0] The value in the shared buffer is: 4 > [1] After change, the value in the shared buffer is: 16053117601147974045 > [1] The value in the shared buffer is: 4 > [2] After change, the value in the shared buffer is: 16053117601147974045 > [2] The value in the shared buffer is: 4 > [3] After change, the value in the shared buffer is: 16053117601147974045 > [3] The value in the shared buffer is: 4 > hashing ! SimGrid-3.11/teshsuite/smpi/shared/CMakeLists.txt000644 001750 001750 00000001446 12342443654 021033 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") if(NOT WIN32) add_executable(shared shared.c) target_link_libraries(shared simgrid) endif() endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/shared.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/shared.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/barrier/000755 001750 001750 00000000000 12342443665 016450 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/barrier/barrier_coll.tesh000644 001750 001750 00000001601 12342443665 021772 0ustar00cici000000 000000 # Smpi scatter collectives tests ! setenv LD_LIBRARY_PATH=../../lib ! output sort p Test barrier $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 16 --log=xbt_cfg.thres:critical ${bindir:=.}/barrier_coll --log=smpi_kernel.thres:warning > ... Barrier .... > You requested to use 16 processes, but there is only 5 processes in your hostfile... > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [rank 0] -> Tremblay > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [rank 12] -> Fafard > [rank 13] -> Ginette > [rank 14] -> Bourassa > [rank 15] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa SimGrid-3.11/teshsuite/smpi/barrier/barrier.c000644 001750 001750 00000001361 12342443660 020236 0ustar00cici000000 000000 /* Copyright (c) 2009, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include int main(int argc, char **argv) { int size, rank; //double start_timer; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); //start_timer = MPI_Wtime(); MPI_Barrier(MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); if (0 == rank) { printf("... Barrier ....\n"); //printf("Elapsed=%f s\n", MPI_Wtime() - start_timer); } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/barrier/CMakeLists.txt000644 001750 001750 00000001435 12342443654 021211 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(barrier_coll barrier.c ) target_link_libraries(barrier_coll simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/barrier_coll.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/barrier.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/compute/000755 001750 001750 00000000000 12342443665 016476 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/compute/compute.tesh000644 001750 001750 00000004225 12342443665 021042 0ustar00cici000000 000000 p Test compute ! timeout 5 $ ${bindir:=.}/../../../bin/smpirun -hostfile ../hostfile -platform ../../../examples/msg/small_platform_with_routers.xml -np 3 --log=root.thres:warning ${bindir:=.}/compute 7 --log=smpi_kernel.thres:warning > 7 16.000000 > 7 16.000000 > 7 16.000000 p Test compute only once ! timeout 5 $ ${bindir:=.}/../../../bin/smpirun -hostfile ../hostfile -platform ../../../examples/msg/small_platform_with_routers.xml -np 3 --log=root.thres:warning ${bindir:=.}/compute2 7 --log=smpi_kernel.thres:warning > 7 16.000000 p Test compute and bench ! output sort ! timeout 45 $ ${bindir:=.}/../../../bin/smpirun -hostfile ../hostfile -platform ../../../examples/msg/small_platform_with_routers.xml -np 3 --log=root.thres:warning ${bindir:=.}/compute3 quiet --log=smpi_kernel.thres:warning > (0) Run the first computation. It's globally benched, and I want no more than 4 benchmarks (thres<0) > (0) Run the first computation. It's globally benched, and I want no more than 4 benchmarks (thres<0) > (0) Run the first computation. It's globally benched, and I want no more than 4 benchmarks (thres<0) > (0) Run the first computation. It's globally benched, and I want no more than 4 benchmarks (thres<0) > (1) [rank:0] Run the first (locally benched) computation. It's locally benched, and I want the standard error to go below 0.1 second (count is not >0) > (1) [rank:0] Run the first (locally benched) computation. It's locally benched, and I want the standard error to go below 0.1 second (count is not >0) > (1) [rank:1] Run the first (locally benched) computation. It's locally benched, and I want the standard error to go below 0.1 second (count is not >0) > (1) [rank:1] Run the first (locally benched) computation. It's locally benched, and I want the standard error to go below 0.1 second (count is not >0) > (1) [rank:2] Run the first (locally benched) computation. It's locally benched, and I want the standard error to go below 0.1 second (count is not >0) > (1) [rank:2] Run the first (locally benched) computation. It's locally benched, and I want the standard error to go below 0.1 second (count is not >0) > (2) [rank:0] Done. > (2) [rank:1] Done. > (2) [rank:2] Done. SimGrid-3.11/teshsuite/smpi/compute/compute3.c000644 001750 001750 00000004173 12342443660 020401 0ustar00cici000000 000000 /* Copyright (c) 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /* This example should be instructive to learn about SMPI_SAMPLE_LOCAL and SMPI_SAMPLE_GLOBAL macros for execution sampling */ #include #include static double compute(double d0) { double d = d0; int j; for (j = 0; j < 100 * 1000 * 1000; j++) { /* 100 kflop */ if (d < 100000) { d = d * d; } else { d = 2; } } return d; } int main(int argc, char *argv[]) { int verbose; int i, n; double d; MPI_Init(&argc, &argv); verbose = argc <= 1; MPI_Comm_size(MPI_COMM_WORLD, &n); d = 2.0; for (i = 0; i < 5; i++) { /* I want no more than n + 1 benchs (thres < 0) */ SMPI_SAMPLE_GLOBAL(n + 1, -1) { if (verbose) fprintf(stderr, "(%12.6f) [rank:%d]", MPI_Wtime(), smpi_process_index()); else fprintf(stderr, "(0)"); fprintf(stderr, " Run the first computation. It's globally benched, " "and I want no more than %d benchmarks (thres<0)\n", n + 1); d = compute(2.0); } } n = 0; for (i = 0; i < 5; i++) { /* I want the standard error to go below 0.1 second. * Two tests at least will be run (count is not > 0) */ SMPI_SAMPLE_LOCAL(0, 0.1) { if (verbose || n++ < 2) { if (verbose) fprintf(stderr, "(%12.6f)", MPI_Wtime()); else fprintf(stderr, "(1)"); fprintf(stderr, " [rank:%d] Run the first (locally benched) computation. " "It's locally benched, and I want the standard error to go " "below 0.1 second (count is not >0)\n", smpi_process_index()); } d = compute(d); } } if (verbose) fprintf(stderr, "(%12.6f) [rank:%d] The result of the computation is: %f\n", MPI_Wtime(), smpi_process_index(), d); else fprintf(stderr, "(2) [rank:%d] Done.\n", smpi_process_index()); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/compute/compute2.c000644 001750 001750 00000001333 12342443660 020373 0ustar00cici000000 000000 /* Copyright (c) 2009-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include int main(int argc, char *argv[]) { int i, n; double d; MPI_Init(&argc, &argv); n = argc > 1 ? atoi(argv[1]) : 0; d = 2.0; /* Run it only once across the whole set of processes */ SMPI_SAMPLE_GLOBAL(1, -1) { for (i = 0; i < n; i++) { if (d < 10000) { d = d * d; } else { d = 2; } } printf("%d %f\n", i, d); } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/compute/compute.c000644 001750 001750 00000001223 12342443660 020307 0ustar00cici000000 000000 /* Copyright (c) 2009-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include int main(int argc, char *argv[]) { int i, n; double d; MPI_Init(&argc, &argv); n = argc > 1 ? atoi(argv[1]) : 0; d = 2.0; for (i = 0; i < n; i++) { if (d < 10000) { d = d * d; } else { d = 2; } } printf("%d %f\n", i, d); MPI_Comm_rank(MPI_COMM_WORLD, &i); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/compute/CMakeLists.txt000644 001750 001750 00000001777 12342443654 021250 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(compute compute.c) add_executable(compute2 compute2.c) add_executable(compute3 compute3.c) target_link_libraries(compute simgrid) target_link_libraries(compute2 simgrid) target_link_libraries(compute3 simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/compute.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/compute.c ${CMAKE_CURRENT_SOURCE_DIR}/compute2.c ${CMAKE_CURRENT_SOURCE_DIR}/compute3.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/vector/000755 001750 001750 00000000000 12342443665 016324 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/vector/vector.tesh000644 001750 001750 00000003154 12342443665 020516 0ustar00cici000000 000000 p Test vector ! setenv LD_LIBRARY_PATH=../../lib ! output sort $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 2 ${bindir:=.}/vector_test -q --log=smpi_kernel.thres:warning > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-3' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'surf/precision' to '1e-9' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [rank 0] -> Tremblay > [rank 1] -> Jupiter > rank= 0, a[0][0]=0.000000 > rank= 0, a[0][1]=1.000000 > rank= 0, a[0][2]=2.000000 > rank= 0, a[0][3]=3.000000 > rank= 0, a[1][0]=4.000000 > rank= 0, a[1][1]=5.000000 > rank= 0, a[1][2]=6.000000 > rank= 0, a[1][3]=7.000000 > rank= 0, a[2][0]=8.000000 > rank= 0, a[2][1]=9.000000 > rank= 0, a[2][2]=10.000000 > rank= 0, a[2][3]=11.000000 > rank= 0, a[3][0]=12.000000 > rank= 0, a[3][1]=13.000000 > rank= 0, a[3][2]=14.000000 > rank= 0, a[3][3]=15.000000 > rank= 1, a[0][0]=0.000000 > rank= 1, a[0][1]=0.000000 > rank= 1, a[0][2]=0.000000 > rank= 1, a[0][3]=0.000000 > rank= 1, a[1][0]=4.000000 > rank= 1, a[1][1]=0.000000 > rank= 1, a[1][2]=0.000000 > rank= 1, a[1][3]=0.000000 > rank= 1, a[2][0]=8.000000 > rank= 1, a[2][1]=0.000000 > rank= 1, a[2][2]=0.000000 > rank= 1, a[2][3]=0.000000 > rank= 1, a[3][0]=12.000000 > rank= 1, a[3][1]=0.000000 > rank= 1, a[3][2]=0.000000 > rank= 1, a[3][3]=0.000000 SimGrid-3.11/teshsuite/smpi/vector/vector_test.c000644 001750 001750 00000002111 12342443660 021017 0ustar00cici000000 000000 /* Copyright (c) 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include "mpi.h" #define SIZE 4 int main(int argc, char **argv) { int rank, i, j; double a[SIZE][SIZE] = {{0}}; MPI_Datatype columntype; MPI_Init(&argc,&argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Type_vector(SIZE, 1, SIZE, MPI_DOUBLE, &columntype); MPI_Type_commit(&columntype); if (rank == 0) { for(i=0; i #endif #if defined(HAVE_STDLIB_H) || defined(STDC_HEADERS) #include #endif #if defined(HAVE_STRING_H) || defined(STDC_HEADERS) #include #endif #ifdef HAVE_STDARG_H #include #endif /* The following two includes permit the collection of resource usage data in the tests */ #ifdef HAVE_SYS_TIME_H #include #endif #ifdef HAVE_SYS_RESOURCE_H #include #endif #include /* * Utility routines for writing MPI tests. * * We check the return codes on all MPI routines (other than INIT) * to allow the program that uses these routines to select MPI_ERRORS_RETURN * as the error handler. We do *not* set MPI_ERRORS_RETURN because * the code that makes use of these routines may not check return * codes. * */ static void MTestRMACleanup( void ); static void MTestResourceSummary( FILE * ); /* Here is where we could put the includes and definitions to enable memory testing */ SMPI_VARINIT_GLOBAL_AND_SET(dbgflag, int, 0); /* Flag used for debugging */ SMPI_VARINIT_GLOBAL_AND_SET(wrank, int, -1); /* World rank */ SMPI_VARINIT_GLOBAL_AND_SET(verbose, int, 0); /* Message level (0 is none) */ SMPI_VARINIT_GLOBAL_AND_SET(returnWithVal, int, 0); /* Allow programs to return with a non-zero if there was an error (may cause problems with some runtime systems) */ SMPI_VARINIT_GLOBAL_AND_SET(usageOutput, int, 0); /* */ /* Provide backward portability to MPI 1 */ #ifndef MPI_VERSION #define MPI_VERSION 1 #endif #if MPI_VERSION < 2 #define MPI_THREAD_SINGLE 0 #endif /* * Initialize and Finalize MTest */ /* Initialize MTest, initializing MPI if necessary. Environment Variables: + MPITEST_DEBUG - If set (to any value), turns on debugging output . MPITEST_THREADLEVEL_DEFAULT - If set, use as the default "provided" level of thread support. Applies to MTest_Init but not MTest_Init_thread. - MPITEST_VERBOSE - If set to a numeric value, turns on that level of verbose output. This is used by the routine 'MTestPrintfMsg' */ void MTest_Init_thread( int *argc, char ***argv, int required, int *provided ) { int flag; char *envval = 0; MPI_Initialized( &flag ); if (!flag) { /* Permit an MPI that claims only MPI 1 but includes the MPI_Init_thread routine (e.g., IBM MPI) */ #if MPI_VERSION >= 2 || defined(HAVE_MPI_INIT_THREAD) MPI_Init_thread( argc, argv, required, provided ); #else MPI_Init( argc, argv ); *provided = -1; #endif } /* Check for debugging control */ if (getenv( "MPITEST_DEBUG" )) { SMPI_VARGET_GLOBAL(dbgflag) = 1; MPI_Comm_rank( MPI_COMM_WORLD, &SMPI_VARGET_GLOBAL(wrank) ); } /* Check for verbose control */ envval = getenv( "MPITEST_VERBOSE" ); if (envval) { char *s; long val = strtol( envval, &s, 0 ); if (s == envval) { /* This is the error case for strtol */ fprintf( stderr, "Warning: %s not valid for MPITEST_VERBOSE\n", envval ); fflush( stderr ); } else { if (val >= 0) { SMPI_VARGET_GLOBAL(verbose) = val; } else { fprintf( stderr, "Warning: %s not valid for MPITEST_VERBOSE\n", envval ); fflush( stderr ); } } } /* Check for option to return success/failure in the return value of main */ envval = getenv( "MPITEST_RETURN_WITH_CODE" ); if (envval) { if (strcmp( envval, "yes" ) == 0 || strcmp( envval, "YES" ) == 0 || strcmp( envval, "true" ) == 0 || strcmp( envval, "TRUE" ) == 0) { SMPI_VARGET_GLOBAL(returnWithVal) = 1; } else if (strcmp( envval, "no" ) == 0 || strcmp( envval, "NO" ) == 0 || strcmp( envval, "false" ) == 0 || strcmp( envval, "FALSE" ) == 0) { SMPI_VARGET_GLOBAL(returnWithVal) = 0; } else { fprintf( stderr, "Warning: %s not valid for MPITEST_RETURN_WITH_CODE\n", envval ); fflush( stderr ); } } /* Print rusage data if set */ if (getenv( "MPITEST_RUSAGE" )) { SMPI_VARGET_GLOBAL(usageOutput) = 1; } } /* * Initialize the tests, using an MPI-1 style init. Supports * MTEST_THREADLEVEL_DEFAULT to test with user-specified thread level */ void MTest_Init( int *argc, char ***argv ) { int provided; #if MPI_VERSION >= 2 || defined(HAVE_MPI_INIT_THREAD) const char *str = 0; int threadLevel; threadLevel = MPI_THREAD_SINGLE; str = getenv( "MTEST_THREADLEVEL_DEFAULT" ); if (!str) str = getenv( "MPITEST_THREADLEVEL_DEFAULT" ); if (str && *str) { if (strcmp(str,"MULTIPLE") == 0 || strcmp(str,"multiple") == 0) { threadLevel = MPI_THREAD_MULTIPLE; } else if (strcmp(str,"SERIALIZED") == 0 || strcmp(str,"serialized") == 0) { threadLevel = MPI_THREAD_SERIALIZED; } else if (strcmp(str,"FUNNELED") == 0 || strcmp(str,"funneled") == 0) { threadLevel = MPI_THREAD_FUNNELED; } else if (strcmp(str,"SINGLE") == 0 || strcmp(str,"single") == 0) { threadLevel = MPI_THREAD_SINGLE; } else { fprintf( stderr, "Unrecognized thread level %s\n", str ); /* Use exit since MPI_Init/Init_thread has not been called. */ exit(1); } } MTest_Init_thread( argc, argv, threadLevel, &provided ); #else /* If the MPI_VERSION is 1, there is no MPI_THREAD_xxx defined */ MTest_Init_thread( argc, argv, 0, &provided ); #endif } /* Finalize MTest. errs is the number of errors on the calling process; this routine will write the total number of errors over all of MPI_COMM_WORLD to the process with rank zero, or " No Errors". It does *not* finalize MPI. */ void MTest_Finalize( int errs ) { int rank, toterrs, merr; merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Reduce( &errs, &toterrs, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD ); if (merr) MTestPrintError( merr ); if (rank == 0) { if (toterrs) { printf( " Found %d errors\n", toterrs ); } else { printf( " No Errors\n" ); } fflush( stdout ); } if (SMPI_VARGET_GLOBAL(usageOutput)) MTestResourceSummary( stdout ); /* Clean up any persistent objects that we allocated */ MTestRMACleanup(); } /* ------------------------------------------------------------------------ */ /* This routine may be used instead of "return 0;" at the end of main; it allows the program to use the return value to signal success or failure. */ int MTestReturnValue( int errors ) { if (SMPI_VARGET_GLOBAL(returnWithVal)) return errors ? 1 : 0; return 0; } /* ------------------------------------------------------------------------ */ /* * Miscellaneous utilities, particularly to eliminate OS dependencies * from the tests. * MTestSleep( seconds ) */ #ifdef HAVE_WINDOWS_H #include void MTestSleep( int sec ) { Sleep( 1000 * sec ); } #else #include void MTestSleep( int sec ) { sleep( sec ); } #endif /* * Datatypes * * Eventually, this could read a description of a file. For now, we hard * code the choices. * * Each kind of datatype has the following functions: * MTestTypeXXXInit - Initialize a send buffer for that type * MTestTypeXXXInitRecv - Initialize a receive buffer for that type * MTestTypeXXXFree - Free any buffers associate with that type * MTestTypeXXXCheckbuf - Check that the buffer contains the expected data * These routines work with (nearly) any datatype that is of type XXX, * allowing the test codes to create a variety of contiguous, vector, and * indexed types, then test them by calling these routines. * * Available types (for the XXX) are * Contig - Simple contiguous buffers * Vector - Simple strided "vector" type * Indexed - Indexed datatype. Only for a count of 1 instance of the * datatype */ SMPI_VARINIT_GLOBAL_AND_SET(datatype_index, int, 0); /* ------------------------------------------------------------------------ */ /* Datatype routines for contiguous datatypes */ /* ------------------------------------------------------------------------ */ /* * Setup contiguous buffers of n copies of a datatype. */ static void *MTestTypeContigInit( MTestDatatype *mtype ) { MPI_Aint size; int merr; if (mtype->count > 0) { signed char *p; int i, totsize; merr = MPI_Type_extent( mtype->datatype, &size ); if (merr) MTestPrintError( merr ); totsize = size * mtype->count; if (!mtype->buf) { mtype->buf = (void *) malloc( totsize ); } p = (signed char *)(mtype->buf); if (!p) { /* Error - out of memory */ MTestError( "Out of memory in type buffer init" ); } for (i=0; ibuf) { free( mtype->buf ); } mtype->buf = 0; } return mtype->buf; } /* * Setup contiguous buffers of n copies of a datatype. Initialize for * reception (e.g., set initial data to detect failure) */ static void *MTestTypeContigInitRecv( MTestDatatype *mtype ) { MPI_Aint size; int merr; if (mtype->count > 0) { signed char *p; int i, totsize; merr = MPI_Type_extent( mtype->datatype, &size ); if (merr) MTestPrintError( merr ); totsize = size * mtype->count; if (!mtype->buf) { mtype->buf = (void *) malloc( totsize ); } p = (signed char *)(mtype->buf); if (!p) { /* Error - out of memory */ MTestError( "Out of memory in type buffer init" ); } for (i=0; ibuf) { free( mtype->buf ); } mtype->buf = 0; } return mtype->buf; } static void *MTestTypeContigFree( MTestDatatype *mtype ) { if (mtype->buf) { free( mtype->buf ); mtype->buf = 0; } return 0; } static int MTestTypeContigCheckbuf( MTestDatatype *mtype ) { unsigned char *p; unsigned char expected; int i, totsize, err = 0, merr; MPI_Aint size; p = (unsigned char *)mtype->buf; if (p) { merr = MPI_Type_extent( mtype->datatype, &size ); if (merr) MTestPrintError( merr ); totsize = size * mtype->count; for (i=0; iprintErrors && err < 10) { printf( "Data expected = %x but got p[%d] = %x\n", expected, i, p[i] ); fflush( stdout ); } } } } return err; } /* ------------------------------------------------------------------------ */ /* Datatype routines for vector datatypes */ /* ------------------------------------------------------------------------ */ static void *MTestTypeVectorInit( MTestDatatype *mtype ) { MPI_Aint size; int merr; if (mtype->count > 0) { unsigned char *p; int i, j, k, nc, totsize; merr = MPI_Type_extent( mtype->datatype, &size ); if (merr) MTestPrintError( merr ); totsize = mtype->count * size; if (!mtype->buf) { mtype->buf = (void *) malloc( totsize ); } p = (unsigned char *)(mtype->buf); if (!p) { /* Error - out of memory */ MTestError( "Out of memory in type buffer init" ); } /* First, set to -1 */ for (i=0; icount; k++) { /* For each element (block) */ for (i=0; inelm; i++) { /* For each value */ for (j=0; jblksize; j++) { p[j] = (0xff ^ (nc & 0xff)); nc++; } p += mtype->stride; } } } else { mtype->buf = 0; } return mtype->buf; } static void *MTestTypeVectorFree( MTestDatatype *mtype ) { if (mtype->buf) { free( mtype->buf ); mtype->buf = 0; } return 0; } /* ------------------------------------------------------------------------ */ /* Datatype routines for indexed block datatypes */ /* ------------------------------------------------------------------------ */ /* * Setup a buffer for one copy of an indexed datatype. */ static void *MTestTypeIndexedInit( MTestDatatype *mtype ) { MPI_Aint totsize; int merr; if (mtype->count > 1) { MTestError( "This datatype is supported only for a single count" ); } if (mtype->count == 1) { signed char *p; int i, k, offset, j; /* Allocate the send/recv buffer */ merr = MPI_Type_extent( mtype->datatype, &totsize ); if (merr) MTestPrintError( merr ); if (!mtype->buf) { mtype->buf = (void *) malloc( totsize ); } p = (signed char *)(mtype->buf); if (!p) { MTestError( "Out of memory in type buffer init\n" ); } /* Initialize the elements */ /* First, set to -1 */ for (i=0; inelm; i++) { int b; /* Compute the offset: */ offset = mtype->displs[i] * mtype->basesize; /* For each element in the block */ for (b=0; bindex[i]; b++) { for (j=0; jbasesize; j++) { p[offset+j] = 0xff ^ (k++ & 0xff); } offset += mtype->basesize; } } } else { /* count == 0 */ if (mtype->buf) { free( mtype->buf ); } mtype->buf = 0; } return mtype->buf; } /* * Setup indexed buffers for 1 copy of a datatype. Initialize for * reception (e.g., set initial data to detect failure) */ static void *MTestTypeIndexedInitRecv( MTestDatatype *mtype ) { MPI_Aint totsize; int merr; if (mtype->count > 1) { MTestError( "This datatype is supported only for a single count" ); } if (mtype->count == 1) { signed char *p; int i; merr = MPI_Type_extent( mtype->datatype, &totsize ); if (merr) MTestPrintError( merr ); if (!mtype->buf) { mtype->buf = (void *) malloc( totsize ); } p = (signed char *)(mtype->buf); if (!p) { /* Error - out of memory */ MTestError( "Out of memory in type buffer init\n" ); } for (i=0; ibuf) { free( mtype->buf ); } mtype->buf = 0; } return mtype->buf; } static void *MTestTypeIndexedFree( MTestDatatype *mtype ) { if (mtype->buf) { free( mtype->buf ); free( mtype->displs ); free( mtype->index ); mtype->buf = 0; mtype->displs = 0; mtype->index = 0; } return 0; } static int MTestTypeIndexedCheckbuf( MTestDatatype *mtype ) { unsigned char *p; unsigned char expected; int i, err = 0, merr; MPI_Aint totsize; p = (unsigned char *)mtype->buf; if (p) { int j, k, offset; merr = MPI_Type_extent( mtype->datatype, &totsize ); if (merr) MTestPrintError( merr ); k = 0; for (i=0; inelm; i++) { int b; /* Compute the offset: */ offset = mtype->displs[i] * mtype->basesize; for (b=0; bindex[i]; b++) { for (j=0; jbasesize; j++) { expected = (0xff ^ (k & 0xff)); if (p[offset+j] != expected) { err++; if (mtype->printErrors && err < 10) { printf( "Data expected = %x but got p[%d,%d] = %x\n", expected, i,j, p[offset+j] ); fflush( stdout ); } } k++; } offset += mtype->basesize; } } } return err; } /* ------------------------------------------------------------------------ */ /* Routines to select a datatype and associated buffer create/fill/check */ /* routines */ /* ------------------------------------------------------------------------ */ /* Create a range of datatypes with a given count elements. This uses a selection of types, rather than an exhaustive collection. It allocates both send and receive types so that they can have the same type signature (collection of basic types) but different type maps (layouts in memory) */ int MTestGetDatatypes( MTestDatatype *sendtype, MTestDatatype *recvtype, int count ) { int merr; int i; sendtype->InitBuf = 0; sendtype->FreeBuf = 0; sendtype->CheckBuf = 0; sendtype->datatype = 0; sendtype->isBasic = 0; sendtype->printErrors = 0; recvtype->InitBuf = 0; recvtype->FreeBuf = 0; recvtype->CheckBuf = 0; recvtype->datatype = 0; recvtype->isBasic = 0; recvtype->printErrors = 0; sendtype->buf = 0; recvtype->buf = 0; /* Set the defaults for the message lengths */ sendtype->count = count; recvtype->count = count; /* Use datatype_index to choose a datatype to use. If at the end of the list, return 0 */ switch (SMPI_VARGET_GLOBAL(datatype_index)) { case 0: sendtype->datatype = MPI_INT; sendtype->isBasic = 1; recvtype->datatype = MPI_INT; recvtype->isBasic = 1; break; case 1: sendtype->datatype = MPI_DOUBLE; sendtype->isBasic = 1; recvtype->datatype = MPI_DOUBLE; recvtype->isBasic = 1; break; case 2: sendtype->datatype = MPI_FLOAT_INT; sendtype->isBasic = 1; recvtype->datatype = MPI_FLOAT_INT; recvtype->isBasic = 1; break; case 3: merr = MPI_Type_dup( MPI_INT, &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_set_name( sendtype->datatype, (char*)"dup of MPI_INT" ); if (merr) MTestPrintError( merr ); merr = MPI_Type_dup( MPI_INT, &recvtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_set_name( recvtype->datatype, (char*)"dup of MPI_INT" ); if (merr) MTestPrintError( merr ); /* dup'ed types are already committed if the original type was committed (MPI-2, section 8.8) */ break; case 4: /* vector send type and contiguous receive type */ /* These sizes are in bytes (see the VectorInit code) */ sendtype->stride = 3 * sizeof(int); sendtype->blksize = sizeof(int); sendtype->nelm = recvtype->count; merr = MPI_Type_vector( recvtype->count, 1, 3, MPI_INT, &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_commit( &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_set_name( sendtype->datatype, (char*)"int-vector" ); if (merr) MTestPrintError( merr ); sendtype->count = 1; recvtype->datatype = MPI_INT; recvtype->isBasic = 1; sendtype->InitBuf = MTestTypeVectorInit; recvtype->InitBuf = MTestTypeContigInitRecv; sendtype->FreeBuf = MTestTypeVectorFree; recvtype->FreeBuf = MTestTypeContigFree; sendtype->CheckBuf = 0; recvtype->CheckBuf = MTestTypeContigCheckbuf; break; case 5: /* Indexed send using many small blocks and contig receive */ sendtype->blksize = sizeof(int); sendtype->nelm = recvtype->count; sendtype->basesize = sizeof(int); sendtype->displs = (int *)malloc( sendtype->nelm * sizeof(int) ); sendtype->index = (int *)malloc( sendtype->nelm * sizeof(int) ); if (!sendtype->displs || !sendtype->index) { MTestError( "Out of memory in type init\n" ); } /* Make the sizes larger (4 ints) to help push the total size to over 256k in some cases, as the MPICH code as of 10/1/06 used large internal buffers for packing non-contiguous messages */ for (i=0; inelm; i++) { sendtype->index[i] = 4; sendtype->displs[i] = 5*i; } merr = MPI_Type_indexed( sendtype->nelm, sendtype->index, sendtype->displs, MPI_INT, &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_commit( &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_set_name( sendtype->datatype, (char*)"int-indexed(4-int)" ); if (merr) MTestPrintError( merr ); sendtype->count = 1; sendtype->InitBuf = MTestTypeIndexedInit; sendtype->FreeBuf = MTestTypeIndexedFree; sendtype->CheckBuf = 0; recvtype->datatype = MPI_INT; recvtype->isBasic = 1; recvtype->count = count * 4; recvtype->InitBuf = MTestTypeContigInitRecv; recvtype->FreeBuf = MTestTypeContigFree; recvtype->CheckBuf = MTestTypeContigCheckbuf; break; case 6: /* Indexed send using 2 large blocks and contig receive */ sendtype->blksize = sizeof(int); sendtype->nelm = 2; sendtype->basesize = sizeof(int); sendtype->displs = (int *)malloc( sendtype->nelm * sizeof(int) ); sendtype->index = (int *)malloc( sendtype->nelm * sizeof(int) ); if (!sendtype->displs || !sendtype->index) { MTestError( "Out of memory in type init\n" ); } /* index -> block size */ sendtype->index[0] = (recvtype->count + 1) / 2; sendtype->displs[0] = 0; sendtype->index[1] = recvtype->count - sendtype->index[0]; sendtype->displs[1] = sendtype->index[0] + 1; /* There is a deliberate gap here */ merr = MPI_Type_indexed( sendtype->nelm, sendtype->index, sendtype->displs, MPI_INT, &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_commit( &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_set_name( sendtype->datatype, (char*)"int-indexed(2 blocks)" ); if (merr) MTestPrintError( merr ); sendtype->count = 1; sendtype->InitBuf = MTestTypeIndexedInit; sendtype->FreeBuf = MTestTypeIndexedFree; sendtype->CheckBuf = 0; recvtype->datatype = MPI_INT; recvtype->isBasic = 1; recvtype->count = sendtype->index[0] + sendtype->index[1]; recvtype->InitBuf = MTestTypeContigInitRecv; recvtype->FreeBuf = MTestTypeContigFree; recvtype->CheckBuf = MTestTypeContigCheckbuf; break; case 7: /* Indexed receive using many small blocks and contig send */ recvtype->blksize = sizeof(int); recvtype->nelm = recvtype->count; recvtype->basesize = sizeof(int); recvtype->displs = (int *)malloc( recvtype->nelm * sizeof(int) ); recvtype->index = (int *)malloc( recvtype->nelm * sizeof(int) ); if (!recvtype->displs || !recvtype->index) { MTestError( "Out of memory in type recv init\n" ); } /* Make the sizes larger (4 ints) to help push the total size to over 256k in some cases, as the MPICH code as of 10/1/06 used large internal buffers for packing non-contiguous messages */ /* Note that there are gaps in the indexed type */ for (i=0; inelm; i++) { recvtype->index[i] = 4; recvtype->displs[i] = 5*i; } merr = MPI_Type_indexed( recvtype->nelm, recvtype->index, recvtype->displs, MPI_INT, &recvtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_commit( &recvtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_set_name( recvtype->datatype, (char*)"recv-int-indexed(4-int)" ); if (merr) MTestPrintError( merr ); recvtype->count = 1; recvtype->InitBuf = MTestTypeIndexedInitRecv; recvtype->FreeBuf = MTestTypeIndexedFree; recvtype->CheckBuf = MTestTypeIndexedCheckbuf; sendtype->datatype = MPI_INT; sendtype->isBasic = 1; sendtype->count = count * 4; sendtype->InitBuf = MTestTypeContigInit; sendtype->FreeBuf = MTestTypeContigFree; sendtype->CheckBuf = 0; break; /* Less commonly used but still simple types */ case 8: sendtype->datatype = MPI_SHORT; sendtype->isBasic = 1; recvtype->datatype = MPI_SHORT; recvtype->isBasic = 1; break; case 9: sendtype->datatype = MPI_LONG; sendtype->isBasic = 1; recvtype->datatype = MPI_LONG; recvtype->isBasic = 1; break; case 10: sendtype->datatype = MPI_CHAR; sendtype->isBasic = 1; recvtype->datatype = MPI_CHAR; recvtype->isBasic = 1; break; case 11: sendtype->datatype = MPI_UINT64_T; sendtype->isBasic = 1; recvtype->datatype = MPI_UINT64_T; recvtype->isBasic = 1; break; case 12: sendtype->datatype = MPI_FLOAT; sendtype->isBasic = 1; recvtype->datatype = MPI_FLOAT; recvtype->isBasic = 1; break; #ifndef USE_STRICT_MPI /* MPI_BYTE may only be used with MPI_BYTE in strict MPI */ case 13: sendtype->datatype = MPI_INT; sendtype->isBasic = 1; recvtype->datatype = MPI_BYTE; recvtype->isBasic = 1; recvtype->count *= sizeof(int); break; #endif default: SMPI_VARGET_GLOBAL(datatype_index) = -1; } if (!sendtype->InitBuf) { sendtype->InitBuf = MTestTypeContigInit; recvtype->InitBuf = MTestTypeContigInitRecv; sendtype->FreeBuf = MTestTypeContigFree; recvtype->FreeBuf = MTestTypeContigFree; sendtype->CheckBuf = MTestTypeContigCheckbuf; recvtype->CheckBuf = MTestTypeContigCheckbuf; } SMPI_VARGET_GLOBAL(datatype_index)++; if (SMPI_VARGET_GLOBAL(dbgflag) && SMPI_VARGET_GLOBAL(datatype_index) > 0) { int typesize; fprintf( stderr, "%d: sendtype is %s\n", SMPI_VARGET_GLOBAL(wrank), MTestGetDatatypeName( sendtype ) ); merr = MPI_Type_size( sendtype->datatype, &typesize ); if (merr) MTestPrintError( merr ); fprintf( stderr, "%d: sendtype size = %d\n", SMPI_VARGET_GLOBAL(wrank), typesize ); fprintf( stderr, "%d: recvtype is %s\n", SMPI_VARGET_GLOBAL(wrank), MTestGetDatatypeName( recvtype ) ); merr = MPI_Type_size( recvtype->datatype, &typesize ); if (merr) MTestPrintError( merr ); fprintf( stderr, "%d: recvtype size = %d\n", SMPI_VARGET_GLOBAL(wrank), typesize ); fflush( stderr ); } else if (SMPI_VARGET_GLOBAL(verbose) && SMPI_VARGET_GLOBAL(datatype_index) > 0) { printf( "Get new datatypes: send = %s, recv = %s\n", MTestGetDatatypeName( sendtype ), MTestGetDatatypeName( recvtype ) ); fflush( stdout ); } return SMPI_VARGET_GLOBAL(datatype_index); } /* Reset the datatype index (start from the initial data type. Note: This routine is rarely needed; MTestGetDatatypes automatically starts over after the last available datatype is used. */ void MTestResetDatatypes( void ) { SMPI_VARGET_GLOBAL(datatype_index) = 0; } /* Return the index of the current datatype. This is rarely needed and is provided mostly to enable debugging of the MTest package itself */ int MTestGetDatatypeIndex( void ) { return SMPI_VARGET_GLOBAL(datatype_index); } /* Free the storage associated with a datatype */ void MTestFreeDatatype( MTestDatatype *mtype ) { int merr; /* Invoke a datatype-specific free function to handle both the datatype and the send/receive buffers */ if (mtype->FreeBuf) { (mtype->FreeBuf)( mtype ); } /* Free the datatype itself if it was created */ if (!mtype->isBasic) { merr = MPI_Type_free( &mtype->datatype ); if (merr) MTestPrintError( merr ); } } /* Check that a message was received correctly. Returns the number of errors detected. Status may be NULL or MPI_STATUS_IGNORE */ int MTestCheckRecv( MPI_Status *status, MTestDatatype *recvtype ) { int count; int errs = 0, merr; if (status && status != MPI_STATUS_IGNORE) { merr = MPI_Get_count( status, recvtype->datatype, &count ); if (merr) MTestPrintError( merr ); /* Check count against expected count */ if (count != recvtype->count) { errs ++; } } /* Check received data */ if (!errs && recvtype->CheckBuf( recvtype )) { errs++; } return errs; } /* This next routine uses a circular buffer of static name arrays just to simplify the use of the routine */ const char *MTestGetDatatypeName( MTestDatatype *dtype ) { typedef char name_type[4][MPI_MAX_OBJECT_NAME]; SMPI_VARINIT_STATIC(name, name_type); SMPI_VARINIT_STATIC_AND_SET(sp, int, 0); int rlen, merr; if (SMPI_VARGET_STATIC(sp) >= 4) SMPI_VARGET_STATIC(sp) = 0; merr = MPI_Type_get_name( dtype->datatype, SMPI_VARGET_STATIC(name)[SMPI_VARGET_STATIC(sp)], &rlen ); if (merr) MTestPrintError( merr ); return (const char *)SMPI_VARGET_STATIC(name)[SMPI_VARGET_STATIC(sp)++]; } /* ----------------------------------------------------------------------- */ /* * Create communicators. Use separate routines for inter and intra * communicators (there is a routine to give both) * Note that the routines may return MPI_COMM_NULL, so code should test for * that return value as well. * */ SMPI_VARINIT_GLOBAL_AND_SET(interCommIdx, int, 0); SMPI_VARINIT_GLOBAL_AND_SET(intraCommIdx, int, 0); SMPI_VARINIT_GLOBAL_AND_SET(intraCommName, const char *, 0); SMPI_VARINIT_GLOBAL_AND_SET(interCommName, const char *, 0); /* * Get an intracommunicator with at least min_size members. If "allowSmaller" * is true, allow the communicator to be smaller than MPI_COMM_WORLD and * for this routine to return MPI_COMM_NULL for some values. Returns 0 if * no more communicators are available. */ int MTestGetIntracommGeneral( MPI_Comm *comm, int min_size, int allowSmaller ) { int size, rank, merr; int done2, done=0; int isBasic = 0; /* The while loop allows us to skip communicators that are too small. MPI_COMM_NULL is always considered large enough */ while (!done) { isBasic = 0; SMPI_VARGET_GLOBAL(intraCommName) = ""; switch (SMPI_VARGET_GLOBAL(intraCommIdx)) { case 0: *comm = MPI_COMM_WORLD; isBasic = 1; SMPI_VARGET_GLOBAL(intraCommName) = "MPI_COMM_WORLD"; break; case 1: /* dup of world */ merr = MPI_Comm_dup(MPI_COMM_WORLD, comm ); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(intraCommName) = "Dup of MPI_COMM_WORLD"; break; case 2: /* reverse ranks */ merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_split( MPI_COMM_WORLD, 0, size-rank, comm ); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(intraCommName) = "Rank reverse of MPI_COMM_WORLD"; break; case 3: /* subset of world, with reversed ranks */ merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_split( MPI_COMM_WORLD, ((rank < size/2) ? 1 : MPI_UNDEFINED), size-rank, comm ); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(intraCommName) = "Rank reverse of half of MPI_COMM_WORLD"; break; case 4: *comm = MPI_COMM_SELF; isBasic = 1; SMPI_VARGET_GLOBAL(intraCommName) = "MPI_COMM_SELF"; break; /* These next cases are communicators that include some but not all of the processes */ case 5: case 6: case 7: case 8: { int newsize; merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); newsize = size - (SMPI_VARGET_GLOBAL(intraCommIdx) - 4); if (allowSmaller && newsize >= min_size) { merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_split( MPI_COMM_WORLD, rank < newsize, rank, comm ); if (merr) MTestPrintError( merr ); if (rank >= newsize) { merr = MPI_Comm_free( comm ); if (merr) MTestPrintError( merr ); *comm = MPI_COMM_NULL; } else { SMPI_VARGET_GLOBAL(intraCommName) = "Split of WORLD"; } } else { /* Act like default */ *comm = MPI_COMM_NULL; SMPI_VARGET_GLOBAL(intraCommIdx) = -1; } } break; /* Other ideas: dup of self, cart comm, graph comm */ default: *comm = MPI_COMM_NULL; SMPI_VARGET_GLOBAL(intraCommIdx) = -1; break; } if (*comm != MPI_COMM_NULL) { merr = MPI_Comm_size( *comm, &size ); if (merr) MTestPrintError( merr ); if (size >= min_size) done = 1; } else { SMPI_VARGET_GLOBAL(intraCommName) = "MPI_COMM_NULL"; isBasic = 1; done = 1; } done2=done; /* we are only done if all processes are done */ MPI_Allreduce(&done2, &done, 1, MPI_INT, MPI_LAND, MPI_COMM_WORLD); /* Advance the comm index whether we are done or not, otherwise we could * spin forever trying to allocate a too-small communicator over and * over again. */ SMPI_VARGET_GLOBAL(intraCommIdx)++; if (!done && !isBasic && *comm != MPI_COMM_NULL) { /* avoid leaking communicators */ merr = MPI_Comm_free(comm); if (merr) MTestPrintError(merr); } } return SMPI_VARGET_GLOBAL(intraCommIdx); } /* * Get an intracommunicator with at least min_size members. */ int MTestGetIntracomm( MPI_Comm *comm, int min_size ) { return MTestGetIntracommGeneral( comm, min_size, 0 ); } /* Return the name of an intra communicator */ const char *MTestGetIntracommName( void ) { return SMPI_VARGET_GLOBAL(intraCommName); } /* * Return an intercomm; set isLeftGroup to 1 if the calling process is * a member of the "left" group. */ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size ) { int size, rank, remsize, merr; int done=0; MPI_Comm mcomm = MPI_COMM_NULL; MPI_Comm mcomm2 = MPI_COMM_NULL; int rleader; /* The while loop allows us to skip communicators that are too small. MPI_COMM_NULL is always considered large enough. The size is the sum of the sizes of the local and remote groups */ while (!done) { *comm = MPI_COMM_NULL; *isLeftGroup = 0; SMPI_VARGET_GLOBAL(interCommName) = "MPI_COMM_NULL"; switch (SMPI_VARGET_GLOBAL(interCommIdx)) { case 0: /* Split comm world in half */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size > 1) { merr = MPI_Comm_split( MPI_COMM_WORLD, (rank < size/2), rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 0) { rleader = size/2; } else if (rank == size/2) { rleader = 0; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank < size/2; merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12345, comm ); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD"; } else *comm = MPI_COMM_NULL; break; case 1: /* Split comm world in to 1 and the rest */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size > 1) { merr = MPI_Comm_split( MPI_COMM_WORLD, rank == 0, rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 0) { rleader = 1; } else if (rank == 1) { rleader = 0; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank == 0; merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12346, comm ); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD into 1, rest"; } else *comm = MPI_COMM_NULL; break; case 2: /* Split comm world in to 2 and the rest */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size > 3) { merr = MPI_Comm_split( MPI_COMM_WORLD, rank < 2, rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 0) { rleader = 2; } else if (rank == 2) { rleader = 0; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank < 2; merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12347, comm ); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD into 2, rest"; } else *comm = MPI_COMM_NULL; break; case 3: /* Split comm world in half, then dup */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size > 1) { merr = MPI_Comm_split( MPI_COMM_WORLD, (rank < size/2), rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 0) { rleader = size/2; } else if (rank == size/2) { rleader = 0; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank < size/2; merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12345, comm ); if (merr) MTestPrintError( merr ); /* avoid leaking after assignment below */ merr = MPI_Comm_free( &mcomm ); if (merr) MTestPrintError( merr ); /* now dup, some bugs only occur for dup's of intercomms */ mcomm = *comm; merr = MPI_Comm_dup(mcomm, comm); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD then dup'ing"; } else *comm = MPI_COMM_NULL; break; case 4: /* Split comm world in half, form intercomm, then split that intercomm */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size > 1) { merr = MPI_Comm_split( MPI_COMM_WORLD, (rank < size/2), rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 0) { rleader = size/2; } else if (rank == size/2) { rleader = 0; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank < size/2; merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12345, comm ); if (merr) MTestPrintError( merr ); /* avoid leaking after assignment below */ merr = MPI_Comm_free( &mcomm ); if (merr) MTestPrintError( merr ); /* now split, some bugs only occur for splits of intercomms */ mcomm = *comm; rank = MPI_Comm_rank(mcomm, &rank); if (merr) MTestPrintError( merr ); /* this split is effectively a dup but tests the split code paths */ merr = MPI_Comm_split(mcomm, 0, rank, comm); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD then then splitting again"; } else *comm = MPI_COMM_NULL; break; case 5: /* split comm world in half discarding rank 0 on the "left" * communicator, then form them into an intercommunicator */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size >= 4) { int color = (rank < size/2 ? 0 : 1); if (rank == 0) color = MPI_UNDEFINED; merr = MPI_Comm_split( MPI_COMM_WORLD, color, rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 1) { rleader = size/2; } else if (rank == (size/2)) { rleader = 1; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank < size/2; if (rank != 0) { /* 0's mcomm is MPI_COMM_NULL */ merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12345, comm ); if (merr) MTestPrintError( merr ); } SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD (discarding rank 0 in the left group) then MPI_Intercomm_create'ing"; } else { *comm = MPI_COMM_NULL; } break; case 6: /* Split comm world in half then form them into an * intercommunicator. Then discard rank 0 from each group of the * intercomm via MPI_Comm_create. */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size >= 4) { MPI_Group oldgroup, newgroup; int ranks[1]; int color = (rank < size/2 ? 0 : 1); merr = MPI_Comm_split( MPI_COMM_WORLD, color, rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 0) { rleader = size/2; } else if (rank == (size/2)) { rleader = 0; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank < size/2; merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12345, &mcomm2 ); if (merr) MTestPrintError( merr ); /* We have an intercomm between the two halves of comm world. Now create * a new intercomm that removes rank 0 on each side. */ merr = MPI_Comm_group(mcomm2, &oldgroup); if (merr) MTestPrintError( merr ); ranks[0] = 0; merr = MPI_Group_excl(oldgroup, 1, ranks, &newgroup); if (merr) MTestPrintError( merr ); merr = MPI_Comm_create(mcomm2, newgroup, comm); if (merr) MTestPrintError( merr ); merr = MPI_Group_free(&oldgroup); if (merr) MTestPrintError( merr ); merr = MPI_Group_free(&newgroup); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD then discarding 0 ranks with MPI_Comm_create"; } else { *comm = MPI_COMM_NULL; } break; default: *comm = MPI_COMM_NULL; SMPI_VARGET_GLOBAL(interCommIdx) = -1; break; } if (*comm != MPI_COMM_NULL) { merr = MPI_Comm_size( *comm, &size ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_remote_size( *comm, &remsize ); if (merr) MTestPrintError( merr ); if (size + remsize >= min_size) done = 1; } else { SMPI_VARGET_GLOBAL(interCommName) = "MPI_COMM_NULL"; done = 1; } /* we are only done if all processes are done */ MPI_Allreduce(MPI_IN_PLACE, &done, 1, MPI_INT, MPI_LAND, MPI_COMM_WORLD); /* Advance the comm index whether we are done or not, otherwise we could * spin forever trying to allocate a too-small communicator over and * over again. */ SMPI_VARGET_GLOBAL(interCommIdx)++; if (!done && *comm != MPI_COMM_NULL) { /* avoid leaking communicators */ merr = MPI_Comm_free(comm); if (merr) MTestPrintError(merr); } /* cleanup for common temp objects */ if (mcomm != MPI_COMM_NULL) { merr = MPI_Comm_free(&mcomm); if (merr) MTestPrintError( merr ); } if (mcomm2 != MPI_COMM_NULL) { merr = MPI_Comm_free(&mcomm2); if (merr) MTestPrintError( merr ); } } return SMPI_VARGET_GLOBAL(interCommIdx); } /* Return the name of an intercommunicator */ const char *MTestGetIntercommName( void ) { return SMPI_VARGET_GLOBAL(interCommName); } /* Get a communicator of a given minimum size. Both intra and inter communicators are provided */ int MTestGetComm( MPI_Comm *comm, int min_size ) { int idx=0; SMPI_VARINIT_STATIC_AND_SET(getinter, int, 0); if (!SMPI_VARGET_STATIC(getinter)) { idx = MTestGetIntracomm( comm, min_size ); if (idx == 0) { SMPI_VARGET_STATIC(getinter) = 1; } } if (SMPI_VARGET_STATIC(getinter)) { int isLeft; idx = MTestGetIntercomm( comm, &isLeft, min_size ); if (idx == 0) { SMPI_VARGET_STATIC(getinter) = 0; } } return idx; } /* Free a communicator. It may be called with a predefined communicator or MPI_COMM_NULL */ void MTestFreeComm( MPI_Comm *comm ) { int merr; if (*comm != MPI_COMM_WORLD && *comm != MPI_COMM_SELF && *comm != MPI_COMM_NULL) { merr = MPI_Comm_free( comm ); if (merr) MTestPrintError( merr ); } } /* ------------------------------------------------------------------------ */ void MTestPrintError( int errcode ) { int errclass, slen; char string[MPI_MAX_ERROR_STRING]; MPI_Error_class( errcode, &errclass ); MPI_Error_string( errcode, string, &slen ); printf( "Error class %d (%s)\n", errclass, string ); fflush( stdout ); } void MTestPrintErrorMsg( const char msg[], int errcode ) { int errclass, slen; char string[MPI_MAX_ERROR_STRING]; MPI_Error_class( errcode, &errclass ); MPI_Error_string( errcode, string, &slen ); printf( "%s: Error class %d (%s)\n", msg, errclass, string ); fflush( stdout ); } /* ------------------------------------------------------------------------ */ /* If verbose output is selected and the level is at least that of the value of the verbose flag, then perform printf( format, ... ); */ void MTestPrintfMsg( int level, const char format[], ... ) { va_list list; if (SMPI_VARGET_GLOBAL(verbose) && level >= SMPI_VARGET_GLOBAL(verbose)) { va_start(list,format); vprintf( format, list ); va_end(list); fflush(stdout); } } /* Fatal error. Report and exit */ void MTestError( const char *msg ) { fprintf( stderr, "%s\n", msg ); fflush( stderr ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } /* ------------------------------------------------------------------------ */ static void MTestResourceSummary( FILE *fp ) { #ifdef HAVE_GETRUSAGE struct rusage ru; SMPI_VARINIT_STATIC_AND_SET(pfThreshold, int, -2); int doOutput = 1; if (getrusage( RUSAGE_SELF, &ru ) == 0) { /* There is an option to generate output only when a resource exceeds a threshold. To date, only page faults supported. */ if (SMPI_VARGET_STATIC(pfThreshold) == -2) { char *p = getenv("MPITEST_RUSAGE_PF"); SMPI_VARGET_STATIC(pfThreshold) = -1; if (p) { SMPI_VARGET_STATIC(pfThreshold) = strtol( p, 0, 0 ); } } if (SMPI_VARGET_STATIC(pfThreshold) > 0) { doOutput = ru.ru_minflt > SMPI_VARGET_STATIC(pfThreshold); } if (doOutput) { /* Cast values to long in case some system has defined them as another integer type */ fprintf( fp, "RUSAGE: max resident set = %ldKB\n", (long)ru.ru_maxrss ); fprintf( fp, "RUSAGE: page faults = %ld : %ld\n", (long)ru.ru_minflt, (long)ru.ru_majflt ); /* Not every Unix provides useful information for the xxrss fields */ fprintf( fp, "RUSAGE: memory in text/data/stack = %ld : %ld : %ld\n", (long)ru.ru_ixrss, (long)ru.ru_idrss, (long)ru.ru_isrss ); fprintf( fp, "RUSAGE: I/O in and out = %ld : %ld\n", (long)ru.ru_inblock, (long)ru.ru_oublock ); fprintf( fp, "RUSAGE: context switch = %ld : %ld\n", (long)ru.ru_nvcsw, (long)ru.ru_nivcsw ); } } else { fprintf( fp, "RUSAGE: return error %d\n", errno ); } #endif } /* ------------------------------------------------------------------------ */ #ifdef HAVE_MPI_WIN_CREATE /* * Create MPI Windows */ SMPI_VARINIT_GLOBAL_AND_SET(win_index, int, 0); SMPI_VARINIT_GLOBAL(winName, const char *); /* Use an attribute to remember the type of memory allocation (static, malloc, or MPI_Alloc_mem) */ SMPI_VARINIT_GLOBAL_AND_SET(mem_keyval, int, MPI_KEYVAL_INVALID); int MTestGetWin( MPI_Win *win, int mustBePassive ) { typedef char actbuf_type[1024]; SMPI_VARINIT_STATIC(actbuf, actbuf_type); SMPI_VARINIT_STATIC(pasbuf, char *); char *buf; int n, rank, merr; MPI_Info info; if (SMPI_VARGET_GLOBAL(mem_keyval) == MPI_KEYVAL_INVALID) { /* Create the keyval */ merr = MPI_Win_create_keyval( MPI_WIN_NULL_COPY_FN, MPI_WIN_NULL_DELETE_FN, &SMPI_VARGET_GLOBAL(mem_keyval), 0 ); if (merr) MTestPrintError( merr ); } switch (SMPI_VARGET_GLOBAL(win_index)) { case 0: /* Active target window */ merr = MPI_Win_create( SMPI_VARGET_STATIC(actbuf), 1024, 1, MPI_INFO_NULL, MPI_COMM_WORLD, win ); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(winName) = "active-window"; merr = MPI_Win_set_attr( *win, SMPI_VARGET_GLOBAL(mem_keyval), (void *)0 ); if (merr) MTestPrintError( merr ); break; case 1: /* Passive target window */ merr = MPI_Alloc_mem( 1024, MPI_INFO_NULL, &SMPI_VARGET_STATIC(pasbuf) ); if (merr) MTestPrintError( merr ); merr = MPI_Win_create( SMPI_VARGET_STATIC(pasbuf), 1024, 1, MPI_INFO_NULL, MPI_COMM_WORLD, win ); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(winName) = "passive-window"; merr = MPI_Win_set_attr( *win, SMPI_VARGET_GLOBAL(mem_keyval), (void *)2 ); if (merr) MTestPrintError( merr ); break; case 2: /* Active target; all windows different sizes */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); n = rank * 64; if (n) buf = (char *)malloc( n ); else buf = 0; merr = MPI_Win_create( buf, n, 1, MPI_INFO_NULL, MPI_COMM_WORLD, win ); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(winName) = "active-all-different-win"; merr = MPI_Win_set_attr( *win, SMPI_VARGET_GLOBAL(mem_keyval), (void *)1 ); if (merr) MTestPrintError( merr ); break; case 3: /* Active target, no locks set */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); n = rank * 64; if (n) buf = (char *)malloc( n ); else buf = 0; merr = MPI_Info_create( &info ); if (merr) MTestPrintError( merr ); merr = MPI_Info_set( info, (char*)"nolocks", (char*)"true" ); if (merr) MTestPrintError( merr ); merr = MPI_Win_create( buf, n, 1, info, MPI_COMM_WORLD, win ); if (merr) MTestPrintError( merr ); merr = MPI_Info_free( &info ); if (merr) MTestPrintError( merr ); SMPI_VARGET_GLOBAL(winName) = "active-nolocks-all-different-win"; merr = MPI_Win_set_attr( *win, SMPI_VARGET_GLOBAL(mem_keyval), (void *)1 ); if (merr) MTestPrintError( merr ); break; default: SMPI_VARGET_GLOBAL(win_index) = -1; } SMPI_VARGET_GLOBAL(win_index)++; return SMPI_VARGET_GLOBAL(win_index); } /* Return a pointer to the name associated with a window object */ const char *MTestGetWinName( void ) { return SMPI_VARGET_GLOBAL(winName); } /* Free the storage associated with a window object */ void MTestFreeWin( MPI_Win *win ) { void *addr; int flag, merr; merr = MPI_Win_get_attr( *win, MPI_WIN_BASE, &addr, &flag ); if (merr) MTestPrintError( merr ); if (!flag) { MTestError( "Could not get WIN_BASE from window" ); } if (addr) { void *val; merr = MPI_Win_get_attr( *win, SMPI_VARGET_GLOBAL(mem_keyval), &val, &flag ); if (merr) MTestPrintError( merr ); if (flag) { if (val == (void *)1) { free( addr ); } else if (val == (void *)2) { merr = MPI_Free_mem( addr ); if (merr) MTestPrintError( merr ); } /* if val == (void *)0, then static data that must not be freed */ } } merr = MPI_Win_free(win); if (merr) MTestPrintError( merr ); } static void MTestRMACleanup( void ) { if (SMPI_VARGET_GLOBAL(mem_keyval) != MPI_KEYVAL_INVALID) { MPI_Win_free_keyval( &SMPI_VARGET_GLOBAL(mem_keyval) ); } } #else static void MTestRMACleanup( void ) {} #endif SimGrid-3.11/teshsuite/smpi/mpich3-test/util/mtest.c000644 001750 001750 00000141276 12342443666 021453 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitestconf.h" #include "mpitest.h" #if defined(HAVE_STDIO_H) || defined(STDC_HEADERS) #include #endif #if defined(HAVE_STDLIB_H) || defined(STDC_HEADERS) #include #endif #if defined(HAVE_STRING_H) || defined(STDC_HEADERS) #include #endif #ifdef HAVE_STDARG_H #include #endif /* The following two includes permit the collection of resource usage data in the tests */ #ifdef HAVE_SYS_TIME_H #include #endif #ifdef HAVE_SYS_RESOURCE_H #include #endif #include /* * Utility routines for writing MPI tests. * * We check the return codes on all MPI routines (other than INIT) * to allow the program that uses these routines to select MPI_ERRORS_RETURN * as the error handler. We do *not* set MPI_ERRORS_RETURN because * the code that makes use of these routines may not check return * codes. * */ static void MTestRMACleanup( void ); static void MTestResourceSummary( FILE * ); /* Here is where we could put the includes and definitions to enable memory testing */ static int dbgflag = 0; /* Flag used for debugging */ static int wrank = -1; /* World rank */ static int verbose = 0; /* Message level (0 is none) */ static int returnWithVal = 0; /* Allow programs to return with a non-zero if there was an error (may cause problems with some runtime systems) */ static int usageOutput = 0; /* */ /* Provide backward portability to MPI 1 */ #ifndef MPI_VERSION #define MPI_VERSION 1 #endif #if MPI_VERSION < 2 #define MPI_THREAD_SINGLE 0 #endif /* * Initialize and Finalize MTest */ /* Initialize MTest, initializing MPI if necessary. Environment Variables: + MPITEST_DEBUG - If set (to any value), turns on debugging output . MPITEST_THREADLEVEL_DEFAULT - If set, use as the default "provided" level of thread support. Applies to MTest_Init but not MTest_Init_thread. - MPITEST_VERBOSE - If set to a numeric value, turns on that level of verbose output. This is used by the routine 'MTestPrintfMsg' */ void MTest_Init_thread( int *argc, char ***argv, int required, int *provided ) { int flag; char *envval = 0; MPI_Initialized( &flag ); if (!flag) { /* Permit an MPI that claims only MPI 1 but includes the MPI_Init_thread routine (e.g., IBM MPI) */ #if MPI_VERSION >= 2 || defined(HAVE_MPI_INIT_THREAD) MPI_Init_thread( argc, argv, required, provided ); #else MPI_Init( argc, argv ); *provided = -1; #endif } /* Check for debugging control */ if (getenv( "MPITEST_DEBUG" )) { dbgflag = 1; MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); } /* Check for verbose control */ envval = getenv( "MPITEST_VERBOSE" ); if (envval) { char *s; long val = strtol( envval, &s, 0 ); if (s == envval) { /* This is the error case for strtol */ fprintf( stderr, "Warning: %s not valid for MPITEST_VERBOSE\n", envval ); fflush( stderr ); } else { if (val >= 0) { verbose = val; } else { fprintf( stderr, "Warning: %s not valid for MPITEST_VERBOSE\n", envval ); fflush( stderr ); } } } /* Check for option to return success/failure in the return value of main */ envval = getenv( "MPITEST_RETURN_WITH_CODE" ); if (envval) { if (strcmp( envval, "yes" ) == 0 || strcmp( envval, "YES" ) == 0 || strcmp( envval, "true" ) == 0 || strcmp( envval, "TRUE" ) == 0) { returnWithVal = 1; } else if (strcmp( envval, "no" ) == 0 || strcmp( envval, "NO" ) == 0 || strcmp( envval, "false" ) == 0 || strcmp( envval, "FALSE" ) == 0) { returnWithVal = 0; } else { fprintf( stderr, "Warning: %s not valid for MPITEST_RETURN_WITH_CODE\n", envval ); fflush( stderr ); } } /* Print rusage data if set */ if (getenv( "MPITEST_RUSAGE" )) { usageOutput = 1; } } /* * Initialize the tests, using an MPI-1 style init. Supports * MTEST_THREADLEVEL_DEFAULT to test with user-specified thread level */ void MTest_Init( int *argc, char ***argv ) { int provided; #if MPI_VERSION >= 2 || defined(HAVE_MPI_INIT_THREAD) const char *str = 0; int threadLevel; threadLevel = MPI_THREAD_SINGLE; str = getenv( "MTEST_THREADLEVEL_DEFAULT" ); if (!str) str = getenv( "MPITEST_THREADLEVEL_DEFAULT" ); if (str && *str) { if (strcmp(str,"MULTIPLE") == 0 || strcmp(str,"multiple") == 0) { threadLevel = MPI_THREAD_MULTIPLE; } else if (strcmp(str,"SERIALIZED") == 0 || strcmp(str,"serialized") == 0) { threadLevel = MPI_THREAD_SERIALIZED; } else if (strcmp(str,"FUNNELED") == 0 || strcmp(str,"funneled") == 0) { threadLevel = MPI_THREAD_FUNNELED; } else if (strcmp(str,"SINGLE") == 0 || strcmp(str,"single") == 0) { threadLevel = MPI_THREAD_SINGLE; } else { fprintf( stderr, "Unrecognized thread level %s\n", str ); /* Use exit since MPI_Init/Init_thread has not been called. */ exit(1); } } MTest_Init_thread( argc, argv, threadLevel, &provided ); #else /* If the MPI_VERSION is 1, there is no MPI_THREAD_xxx defined */ MTest_Init_thread( argc, argv, 0, &provided ); #endif } /* Finalize MTest. errs is the number of errors on the calling process; this routine will write the total number of errors over all of MPI_COMM_WORLD to the process with rank zero, or " No Errors". It does *not* finalize MPI. */ void MTest_Finalize( int errs ) { int rank, toterrs, merr; merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Reduce( &errs, &toterrs, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD ); if (merr) MTestPrintError( merr ); if (rank == 0) { if (toterrs) { printf( " Found %d errors\n", toterrs ); } else { printf( " No Errors\n" ); } fflush( stdout ); } if (usageOutput) MTestResourceSummary( stdout ); /* Clean up any persistent objects that we allocated */ MTestRMACleanup(); } /* ------------------------------------------------------------------------ */ /* This routine may be used instead of "return 0;" at the end of main; it allows the program to use the return value to signal success or failure. */ int MTestReturnValue( int errors ) { if (returnWithVal) return errors ? 1 : 0; return 0; } /* ------------------------------------------------------------------------ */ /* * Miscellaneous utilities, particularly to eliminate OS dependencies * from the tests. * MTestSleep( seconds ) */ #ifdef HAVE_WINDOWS_H #include void MTestSleep( int sec ) { Sleep( 1000 * sec ); } #else #include void MTestSleep( int sec ) { sleep( sec ); } #endif /* * Datatypes * * Eventually, this could read a description of a file. For now, we hard * code the choices. * * Each kind of datatype has the following functions: * MTestTypeXXXInit - Initialize a send buffer for that type * MTestTypeXXXInitRecv - Initialize a receive buffer for that type * MTestTypeXXXFree - Free any buffers associate with that type * MTestTypeXXXCheckbuf - Check that the buffer contains the expected data * These routines work with (nearly) any datatype that is of type XXX, * allowing the test codes to create a variety of contiguous, vector, and * indexed types, then test them by calling these routines. * * Available types (for the XXX) are * Contig - Simple contiguous buffers * Vector - Simple strided "vector" type * Indexed - Indexed datatype. Only for a count of 1 instance of the * datatype */ static int datatype_index = 0; /* ------------------------------------------------------------------------ */ /* Datatype routines for contiguous datatypes */ /* ------------------------------------------------------------------------ */ /* * Setup contiguous buffers of n copies of a datatype. */ static void *MTestTypeContigInit( MTestDatatype *mtype ) { MPI_Aint size; int merr; if (mtype->count > 0) { signed char *p; int i, totsize; merr = MPI_Type_extent( mtype->datatype, &size ); if (merr) MTestPrintError( merr ); totsize = size * mtype->count; if (!mtype->buf) { mtype->buf = (void *) malloc( totsize ); } p = (signed char *)(mtype->buf); if (!p) { /* Error - out of memory */ MTestError( "Out of memory in type buffer init" ); } for (i=0; ibuf) { free( mtype->buf ); } mtype->buf = 0; } return mtype->buf; } /* * Setup contiguous buffers of n copies of a datatype. Initialize for * reception (e.g., set initial data to detect failure) */ static void *MTestTypeContigInitRecv( MTestDatatype *mtype ) { MPI_Aint size; int merr; if (mtype->count > 0) { signed char *p; int i, totsize; merr = MPI_Type_extent( mtype->datatype, &size ); if (merr) MTestPrintError( merr ); totsize = size * mtype->count; if (!mtype->buf) { mtype->buf = (void *) malloc( totsize ); } p = (signed char *)(mtype->buf); if (!p) { /* Error - out of memory */ MTestError( "Out of memory in type buffer init" ); } for (i=0; ibuf) { free( mtype->buf ); } mtype->buf = 0; } return mtype->buf; } static void *MTestTypeContigFree( MTestDatatype *mtype ) { if (mtype->buf) { free( mtype->buf ); mtype->buf = 0; } return 0; } static int MTestTypeContigCheckbuf( MTestDatatype *mtype ) { unsigned char *p; unsigned char expected; int i, totsize, err = 0, merr; MPI_Aint size; p = (unsigned char *)mtype->buf; if (p) { merr = MPI_Type_extent( mtype->datatype, &size ); if (merr) MTestPrintError( merr ); totsize = size * mtype->count; for (i=0; iprintErrors && err < 10) { printf( "Data expected = %x but got p[%d] = %x\n", expected, i, p[i] ); fflush( stdout ); } } } } return err; } /* ------------------------------------------------------------------------ */ /* Datatype routines for vector datatypes */ /* ------------------------------------------------------------------------ */ static void *MTestTypeVectorInit( MTestDatatype *mtype ) { MPI_Aint size; int merr; if (mtype->count > 0) { unsigned char *p; int i, j, k, nc, totsize; merr = MPI_Type_extent( mtype->datatype, &size ); if (merr) MTestPrintError( merr ); totsize = mtype->count * size; if (!mtype->buf) { mtype->buf = (void *) malloc( totsize ); } p = (unsigned char *)(mtype->buf); if (!p) { /* Error - out of memory */ MTestError( "Out of memory in type buffer init" ); } /* First, set to -1 */ for (i=0; icount; k++) { /* For each element (block) */ for (i=0; inelm; i++) { /* For each value */ for (j=0; jblksize; j++) { p[j] = (0xff ^ (nc & 0xff)); nc++; } p += mtype->stride; } } } else { mtype->buf = 0; } return mtype->buf; } static void *MTestTypeVectorFree( MTestDatatype *mtype ) { if (mtype->buf) { free( mtype->buf ); mtype->buf = 0; } return 0; } /* ------------------------------------------------------------------------ */ /* Datatype routines for indexed block datatypes */ /* ------------------------------------------------------------------------ */ /* * Setup a buffer for one copy of an indexed datatype. */ static void *MTestTypeIndexedInit( MTestDatatype *mtype ) { MPI_Aint totsize; int merr; if (mtype->count > 1) { MTestError( "This datatype is supported only for a single count" ); } if (mtype->count == 1) { signed char *p; int i, k, offset, j; /* Allocate the send/recv buffer */ merr = MPI_Type_extent( mtype->datatype, &totsize ); if (merr) MTestPrintError( merr ); if (!mtype->buf) { mtype->buf = (void *) malloc( totsize ); } p = (signed char *)(mtype->buf); if (!p) { MTestError( "Out of memory in type buffer init\n" ); } /* Initialize the elements */ /* First, set to -1 */ for (i=0; inelm; i++) { int b; /* Compute the offset: */ offset = mtype->displs[i] * mtype->basesize; /* For each element in the block */ for (b=0; bindex[i]; b++) { for (j=0; jbasesize; j++) { p[offset+j] = 0xff ^ (k++ & 0xff); } offset += mtype->basesize; } } } else { /* count == 0 */ if (mtype->buf) { free( mtype->buf ); } mtype->buf = 0; } return mtype->buf; } /* * Setup indexed buffers for 1 copy of a datatype. Initialize for * reception (e.g., set initial data to detect failure) */ static void *MTestTypeIndexedInitRecv( MTestDatatype *mtype ) { MPI_Aint totsize; int merr; if (mtype->count > 1) { MTestError( "This datatype is supported only for a single count" ); } if (mtype->count == 1) { signed char *p; int i; merr = MPI_Type_extent( mtype->datatype, &totsize ); if (merr) MTestPrintError( merr ); if (!mtype->buf) { mtype->buf = (void *) malloc( totsize ); } p = (signed char *)(mtype->buf); if (!p) { /* Error - out of memory */ MTestError( "Out of memory in type buffer init\n" ); } for (i=0; ibuf) { free( mtype->buf ); } mtype->buf = 0; } return mtype->buf; } static void *MTestTypeIndexedFree( MTestDatatype *mtype ) { if (mtype->buf) { free( mtype->buf ); free( mtype->displs ); free( mtype->index ); mtype->buf = 0; mtype->displs = 0; mtype->index = 0; } return 0; } static int MTestTypeIndexedCheckbuf( MTestDatatype *mtype ) { unsigned char *p; unsigned char expected; int i, err = 0, merr; MPI_Aint totsize; p = (unsigned char *)mtype->buf; if (p) { int j, k, offset; merr = MPI_Type_extent( mtype->datatype, &totsize ); if (merr) MTestPrintError( merr ); k = 0; for (i=0; inelm; i++) { int b; /* Compute the offset: */ offset = mtype->displs[i] * mtype->basesize; for (b=0; bindex[i]; b++) { for (j=0; jbasesize; j++) { expected = (0xff ^ (k & 0xff)); if (p[offset+j] != expected) { err++; if (mtype->printErrors && err < 10) { printf( "Data expected = %x but got p[%d,%d] = %x\n", expected, i,j, p[offset+j] ); fflush( stdout ); } } k++; } offset += mtype->basesize; } } } return err; } /* ------------------------------------------------------------------------ */ /* Routines to select a datatype and associated buffer create/fill/check */ /* routines */ /* ------------------------------------------------------------------------ */ /* Create a range of datatypes with a given count elements. This uses a selection of types, rather than an exhaustive collection. It allocates both send and receive types so that they can have the same type signature (collection of basic types) but different type maps (layouts in memory) */ int MTestGetDatatypes( MTestDatatype *sendtype, MTestDatatype *recvtype, int count ) { int merr; int i; sendtype->InitBuf = 0; sendtype->FreeBuf = 0; sendtype->CheckBuf = 0; sendtype->datatype = 0; sendtype->isBasic = 0; sendtype->printErrors = 0; recvtype->InitBuf = 0; recvtype->FreeBuf = 0; recvtype->CheckBuf = 0; recvtype->datatype = 0; recvtype->isBasic = 0; recvtype->printErrors = 0; sendtype->buf = 0; recvtype->buf = 0; /* Set the defaults for the message lengths */ sendtype->count = count; recvtype->count = count; /* Use datatype_index to choose a datatype to use. If at the end of the list, return 0 */ switch (datatype_index) { case 0: sendtype->datatype = MPI_INT; sendtype->isBasic = 1; recvtype->datatype = MPI_INT; recvtype->isBasic = 1; break; case 1: sendtype->datatype = MPI_DOUBLE; sendtype->isBasic = 1; recvtype->datatype = MPI_DOUBLE; recvtype->isBasic = 1; break; case 2: sendtype->datatype = MPI_FLOAT_INT; sendtype->isBasic = 1; recvtype->datatype = MPI_FLOAT_INT; recvtype->isBasic = 1; break; case 3: merr = MPI_Type_dup( MPI_INT, &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_set_name( sendtype->datatype, (char*)"dup of MPI_INT" ); if (merr) MTestPrintError( merr ); merr = MPI_Type_dup( MPI_INT, &recvtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_set_name( recvtype->datatype, (char*)"dup of MPI_INT" ); if (merr) MTestPrintError( merr ); /* dup'ed types are already committed if the original type was committed (MPI-2, section 8.8) */ break; case 4: /* vector send type and contiguous receive type */ /* These sizes are in bytes (see the VectorInit code) */ sendtype->stride = 3 * sizeof(int); sendtype->blksize = sizeof(int); sendtype->nelm = recvtype->count; merr = MPI_Type_vector( recvtype->count, 1, 3, MPI_INT, &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_commit( &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_set_name( sendtype->datatype, (char*)"int-vector" ); if (merr) MTestPrintError( merr ); sendtype->count = 1; recvtype->datatype = MPI_INT; recvtype->isBasic = 1; sendtype->InitBuf = MTestTypeVectorInit; recvtype->InitBuf = MTestTypeContigInitRecv; sendtype->FreeBuf = MTestTypeVectorFree; recvtype->FreeBuf = MTestTypeContigFree; sendtype->CheckBuf = 0; recvtype->CheckBuf = MTestTypeContigCheckbuf; break; case 5: /* Indexed send using many small blocks and contig receive */ sendtype->blksize = sizeof(int); sendtype->nelm = recvtype->count; sendtype->basesize = sizeof(int); sendtype->displs = (int *)malloc( sendtype->nelm * sizeof(int) ); sendtype->index = (int *)malloc( sendtype->nelm * sizeof(int) ); if (!sendtype->displs || !sendtype->index) { MTestError( "Out of memory in type init\n" ); } /* Make the sizes larger (4 ints) to help push the total size to over 256k in some cases, as the MPICH code as of 10/1/06 used large internal buffers for packing non-contiguous messages */ for (i=0; inelm; i++) { sendtype->index[i] = 4; sendtype->displs[i] = 5*i; } merr = MPI_Type_indexed( sendtype->nelm, sendtype->index, sendtype->displs, MPI_INT, &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_commit( &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_set_name( sendtype->datatype, (char*)"int-indexed(4-int)" ); if (merr) MTestPrintError( merr ); sendtype->count = 1; sendtype->InitBuf = MTestTypeIndexedInit; sendtype->FreeBuf = MTestTypeIndexedFree; sendtype->CheckBuf = 0; recvtype->datatype = MPI_INT; recvtype->isBasic = 1; recvtype->count = count * 4; recvtype->InitBuf = MTestTypeContigInitRecv; recvtype->FreeBuf = MTestTypeContigFree; recvtype->CheckBuf = MTestTypeContigCheckbuf; break; case 6: /* Indexed send using 2 large blocks and contig receive */ sendtype->blksize = sizeof(int); sendtype->nelm = 2; sendtype->basesize = sizeof(int); sendtype->displs = (int *)malloc( sendtype->nelm * sizeof(int) ); sendtype->index = (int *)malloc( sendtype->nelm * sizeof(int) ); if (!sendtype->displs || !sendtype->index) { MTestError( "Out of memory in type init\n" ); } /* index -> block size */ sendtype->index[0] = (recvtype->count + 1) / 2; sendtype->displs[0] = 0; sendtype->index[1] = recvtype->count - sendtype->index[0]; sendtype->displs[1] = sendtype->index[0] + 1; /* There is a deliberate gap here */ merr = MPI_Type_indexed( sendtype->nelm, sendtype->index, sendtype->displs, MPI_INT, &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_commit( &sendtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_set_name( sendtype->datatype, (char*)"int-indexed(2 blocks)" ); if (merr) MTestPrintError( merr ); sendtype->count = 1; sendtype->InitBuf = MTestTypeIndexedInit; sendtype->FreeBuf = MTestTypeIndexedFree; sendtype->CheckBuf = 0; recvtype->datatype = MPI_INT; recvtype->isBasic = 1; recvtype->count = sendtype->index[0] + sendtype->index[1]; recvtype->InitBuf = MTestTypeContigInitRecv; recvtype->FreeBuf = MTestTypeContigFree; recvtype->CheckBuf = MTestTypeContigCheckbuf; break; case 7: /* Indexed receive using many small blocks and contig send */ recvtype->blksize = sizeof(int); recvtype->nelm = recvtype->count; recvtype->basesize = sizeof(int); recvtype->displs = (int *)malloc( recvtype->nelm * sizeof(int) ); recvtype->index = (int *)malloc( recvtype->nelm * sizeof(int) ); if (!recvtype->displs || !recvtype->index) { MTestError( "Out of memory in type recv init\n" ); } /* Make the sizes larger (4 ints) to help push the total size to over 256k in some cases, as the MPICH code as of 10/1/06 used large internal buffers for packing non-contiguous messages */ /* Note that there are gaps in the indexed type */ for (i=0; inelm; i++) { recvtype->index[i] = 4; recvtype->displs[i] = 5*i; } merr = MPI_Type_indexed( recvtype->nelm, recvtype->index, recvtype->displs, MPI_INT, &recvtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_commit( &recvtype->datatype ); if (merr) MTestPrintError( merr ); merr = MPI_Type_set_name( recvtype->datatype, (char*)"recv-int-indexed(4-int)" ); if (merr) MTestPrintError( merr ); recvtype->count = 1; recvtype->InitBuf = MTestTypeIndexedInitRecv; recvtype->FreeBuf = MTestTypeIndexedFree; recvtype->CheckBuf = MTestTypeIndexedCheckbuf; sendtype->datatype = MPI_INT; sendtype->isBasic = 1; sendtype->count = count * 4; sendtype->InitBuf = MTestTypeContigInit; sendtype->FreeBuf = MTestTypeContigFree; sendtype->CheckBuf = 0; break; /* Less commonly used but still simple types */ case 8: sendtype->datatype = MPI_SHORT; sendtype->isBasic = 1; recvtype->datatype = MPI_SHORT; recvtype->isBasic = 1; break; case 9: sendtype->datatype = MPI_LONG; sendtype->isBasic = 1; recvtype->datatype = MPI_LONG; recvtype->isBasic = 1; break; case 10: sendtype->datatype = MPI_CHAR; sendtype->isBasic = 1; recvtype->datatype = MPI_CHAR; recvtype->isBasic = 1; break; case 11: sendtype->datatype = MPI_UINT64_T; sendtype->isBasic = 1; recvtype->datatype = MPI_UINT64_T; recvtype->isBasic = 1; break; case 12: sendtype->datatype = MPI_FLOAT; sendtype->isBasic = 1; recvtype->datatype = MPI_FLOAT; recvtype->isBasic = 1; break; #ifndef USE_STRICT_MPI /* MPI_BYTE may only be used with MPI_BYTE in strict MPI */ case 13: sendtype->datatype = MPI_INT; sendtype->isBasic = 1; recvtype->datatype = MPI_BYTE; recvtype->isBasic = 1; recvtype->count *= sizeof(int); break; #endif default: datatype_index = -1; } if (!sendtype->InitBuf) { sendtype->InitBuf = MTestTypeContigInit; recvtype->InitBuf = MTestTypeContigInitRecv; sendtype->FreeBuf = MTestTypeContigFree; recvtype->FreeBuf = MTestTypeContigFree; sendtype->CheckBuf = MTestTypeContigCheckbuf; recvtype->CheckBuf = MTestTypeContigCheckbuf; } datatype_index++; if (dbgflag && datatype_index > 0) { int typesize; fprintf( stderr, "%d: sendtype is %s\n", wrank, MTestGetDatatypeName( sendtype ) ); merr = MPI_Type_size( sendtype->datatype, &typesize ); if (merr) MTestPrintError( merr ); fprintf( stderr, "%d: sendtype size = %d\n", wrank, typesize ); fprintf( stderr, "%d: recvtype is %s\n", wrank, MTestGetDatatypeName( recvtype ) ); merr = MPI_Type_size( recvtype->datatype, &typesize ); if (merr) MTestPrintError( merr ); fprintf( stderr, "%d: recvtype size = %d\n", wrank, typesize ); fflush( stderr ); } else if (verbose && datatype_index > 0) { printf( "Get new datatypes: send = %s, recv = %s\n", MTestGetDatatypeName( sendtype ), MTestGetDatatypeName( recvtype ) ); fflush( stdout ); } return datatype_index; } /* Reset the datatype index (start from the initial data type. Note: This routine is rarely needed; MTestGetDatatypes automatically starts over after the last available datatype is used. */ void MTestResetDatatypes( void ) { datatype_index = 0; } /* Return the index of the current datatype. This is rarely needed and is provided mostly to enable debugging of the MTest package itself */ int MTestGetDatatypeIndex( void ) { return datatype_index; } /* Free the storage associated with a datatype */ void MTestFreeDatatype( MTestDatatype *mtype ) { int merr; /* Invoke a datatype-specific free function to handle both the datatype and the send/receive buffers */ if (mtype->FreeBuf) { (mtype->FreeBuf)( mtype ); } /* Free the datatype itself if it was created */ if (!mtype->isBasic) { merr = MPI_Type_free( &mtype->datatype ); if (merr) MTestPrintError( merr ); } } /* Check that a message was received correctly. Returns the number of errors detected. Status may be NULL or MPI_STATUS_IGNORE */ int MTestCheckRecv( MPI_Status *status, MTestDatatype *recvtype ) { int count; int errs = 0, merr; if (status && status != MPI_STATUS_IGNORE) { merr = MPI_Get_count( status, recvtype->datatype, &count ); if (merr) MTestPrintError( merr ); /* Check count against expected count */ if (count != recvtype->count) { errs ++; } } /* Check received data */ if (!errs && recvtype->CheckBuf( recvtype )) { errs++; } return errs; } /* This next routine uses a circular buffer of static name arrays just to simplify the use of the routine */ const char *MTestGetDatatypeName( MTestDatatype *dtype ) { static char name[4][MPI_MAX_OBJECT_NAME]; static int sp=0; int rlen, merr; if (sp >= 4) sp = 0; merr = MPI_Type_get_name( dtype->datatype, name[sp], &rlen ); if (merr) MTestPrintError( merr ); return (const char *)name[sp++]; } /* ----------------------------------------------------------------------- */ /* * Create communicators. Use separate routines for inter and intra * communicators (there is a routine to give both) * Note that the routines may return MPI_COMM_NULL, so code should test for * that return value as well. * */ static int interCommIdx = 0; static int intraCommIdx = 0; static const char *intraCommName = 0; static const char *interCommName = 0; /* * Get an intracommunicator with at least min_size members. If "allowSmaller" * is true, allow the communicator to be smaller than MPI_COMM_WORLD and * for this routine to return MPI_COMM_NULL for some values. Returns 0 if * no more communicators are available. */ int MTestGetIntracommGeneral( MPI_Comm *comm, int min_size, int allowSmaller ) { int size, rank, merr; int done2, done=0; int isBasic = 0; /* The while loop allows us to skip communicators that are too small. MPI_COMM_NULL is always considered large enough */ while (!done) { isBasic = 0; intraCommName = ""; switch (intraCommIdx) { case 0: *comm = MPI_COMM_WORLD; isBasic = 1; intraCommName = "MPI_COMM_WORLD"; break; case 1: /* dup of world */ merr = MPI_Comm_dup(MPI_COMM_WORLD, comm ); if (merr) MTestPrintError( merr ); intraCommName = "Dup of MPI_COMM_WORLD"; break; case 2: /* reverse ranks */ merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_split( MPI_COMM_WORLD, 0, size-rank, comm ); if (merr) MTestPrintError( merr ); intraCommName = "Rank reverse of MPI_COMM_WORLD"; break; case 3: /* subset of world, with reversed ranks */ merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_split( MPI_COMM_WORLD, ((rank < size/2) ? 1 : MPI_UNDEFINED), size-rank, comm ); if (merr) MTestPrintError( merr ); intraCommName = "Rank reverse of half of MPI_COMM_WORLD"; break; case 4: *comm = MPI_COMM_SELF; isBasic = 1; intraCommName = "MPI_COMM_SELF"; break; /* These next cases are communicators that include some but not all of the processes */ case 5: case 6: case 7: case 8: { int newsize; merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); newsize = size - (intraCommIdx - 4); if (allowSmaller && newsize >= min_size) { merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_split( MPI_COMM_WORLD, rank < newsize, rank, comm ); if (merr) MTestPrintError( merr ); if (rank >= newsize) { merr = MPI_Comm_free( comm ); if (merr) MTestPrintError( merr ); *comm = MPI_COMM_NULL; } else { intraCommName = "Split of WORLD"; } } else { /* Act like default */ *comm = MPI_COMM_NULL; intraCommIdx = -1; } } break; /* Other ideas: dup of self, cart comm, graph comm */ default: *comm = MPI_COMM_NULL; intraCommIdx = -1; break; } if (*comm != MPI_COMM_NULL) { merr = MPI_Comm_size( *comm, &size ); if (merr) MTestPrintError( merr ); if (size >= min_size) done = 1; } else { intraCommName = "MPI_COMM_NULL"; isBasic = 1; done = 1; } done2=done; /* we are only done if all processes are done */ MPI_Allreduce(&done2, &done, 1, MPI_INT, MPI_LAND, MPI_COMM_WORLD); /* Advance the comm index whether we are done or not, otherwise we could * spin forever trying to allocate a too-small communicator over and * over again. */ intraCommIdx++; if (!done && !isBasic && *comm != MPI_COMM_NULL) { /* avoid leaking communicators */ merr = MPI_Comm_free(comm); if (merr) MTestPrintError(merr); } } return intraCommIdx; } /* * Get an intracommunicator with at least min_size members. */ int MTestGetIntracomm( MPI_Comm *comm, int min_size ) { return MTestGetIntracommGeneral( comm, min_size, 0 ); } /* Return the name of an intra communicator */ const char *MTestGetIntracommName( void ) { return intraCommName; } /* * Return an intercomm; set isLeftGroup to 1 if the calling process is * a member of the "left" group. */ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size ) { int size, rank, remsize, merr; int done=0; MPI_Comm mcomm = MPI_COMM_NULL; MPI_Comm mcomm2 = MPI_COMM_NULL; int rleader; /* The while loop allows us to skip communicators that are too small. MPI_COMM_NULL is always considered large enough. The size is the sum of the sizes of the local and remote groups */ while (!done) { *comm = MPI_COMM_NULL; *isLeftGroup = 0; interCommName = "MPI_COMM_NULL"; switch (interCommIdx) { case 0: /* Split comm world in half */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size > 1) { merr = MPI_Comm_split( MPI_COMM_WORLD, (rank < size/2), rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 0) { rleader = size/2; } else if (rank == size/2) { rleader = 0; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank < size/2; merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12345, comm ); if (merr) MTestPrintError( merr ); interCommName = "Intercomm by splitting MPI_COMM_WORLD"; } else *comm = MPI_COMM_NULL; break; case 1: /* Split comm world in to 1 and the rest */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size > 1) { merr = MPI_Comm_split( MPI_COMM_WORLD, rank == 0, rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 0) { rleader = 1; } else if (rank == 1) { rleader = 0; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank == 0; merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12346, comm ); if (merr) MTestPrintError( merr ); interCommName = "Intercomm by splitting MPI_COMM_WORLD into 1, rest"; } else *comm = MPI_COMM_NULL; break; case 2: /* Split comm world in to 2 and the rest */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size > 3) { merr = MPI_Comm_split( MPI_COMM_WORLD, rank < 2, rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 0) { rleader = 2; } else if (rank == 2) { rleader = 0; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank < 2; merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12347, comm ); if (merr) MTestPrintError( merr ); interCommName = "Intercomm by splitting MPI_COMM_WORLD into 2, rest"; } else *comm = MPI_COMM_NULL; break; case 3: /* Split comm world in half, then dup */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size > 1) { merr = MPI_Comm_split( MPI_COMM_WORLD, (rank < size/2), rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 0) { rleader = size/2; } else if (rank == size/2) { rleader = 0; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank < size/2; merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12345, comm ); if (merr) MTestPrintError( merr ); /* avoid leaking after assignment below */ merr = MPI_Comm_free( &mcomm ); if (merr) MTestPrintError( merr ); /* now dup, some bugs only occur for dup's of intercomms */ mcomm = *comm; merr = MPI_Comm_dup(mcomm, comm); if (merr) MTestPrintError( merr ); interCommName = "Intercomm by splitting MPI_COMM_WORLD then dup'ing"; } else *comm = MPI_COMM_NULL; break; case 4: /* Split comm world in half, form intercomm, then split that intercomm */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size > 1) { merr = MPI_Comm_split( MPI_COMM_WORLD, (rank < size/2), rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 0) { rleader = size/2; } else if (rank == size/2) { rleader = 0; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank < size/2; merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12345, comm ); if (merr) MTestPrintError( merr ); /* avoid leaking after assignment below */ merr = MPI_Comm_free( &mcomm ); if (merr) MTestPrintError( merr ); /* now split, some bugs only occur for splits of intercomms */ mcomm = *comm; rank = MPI_Comm_rank(mcomm, &rank); if (merr) MTestPrintError( merr ); /* this split is effectively a dup but tests the split code paths */ merr = MPI_Comm_split(mcomm, 0, rank, comm); if (merr) MTestPrintError( merr ); interCommName = "Intercomm by splitting MPI_COMM_WORLD then then splitting again"; } else *comm = MPI_COMM_NULL; break; case 5: /* split comm world in half discarding rank 0 on the "left" * communicator, then form them into an intercommunicator */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size >= 4) { int color = (rank < size/2 ? 0 : 1); if (rank == 0) color = MPI_UNDEFINED; merr = MPI_Comm_split( MPI_COMM_WORLD, color, rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 1) { rleader = size/2; } else if (rank == (size/2)) { rleader = 1; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank < size/2; if (rank != 0) { /* 0's mcomm is MPI_COMM_NULL */ merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12345, comm ); if (merr) MTestPrintError( merr ); } interCommName = "Intercomm by splitting MPI_COMM_WORLD (discarding rank 0 in the left group) then MPI_Intercomm_create'ing"; } else { *comm = MPI_COMM_NULL; } break; case 6: /* Split comm world in half then form them into an * intercommunicator. Then discard rank 0 from each group of the * intercomm via MPI_Comm_create. */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_size( MPI_COMM_WORLD, &size ); if (merr) MTestPrintError( merr ); if (size >= 4) { MPI_Group oldgroup, newgroup; int ranks[1]; int color = (rank < size/2 ? 0 : 1); merr = MPI_Comm_split( MPI_COMM_WORLD, color, rank, &mcomm ); if (merr) MTestPrintError( merr ); if (rank == 0) { rleader = size/2; } else if (rank == (size/2)) { rleader = 0; } else { /* Remote leader is signficant only for the processes designated local leaders */ rleader = -1; } *isLeftGroup = rank < size/2; merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12345, &mcomm2 ); if (merr) MTestPrintError( merr ); /* We have an intercomm between the two halves of comm world. Now create * a new intercomm that removes rank 0 on each side. */ merr = MPI_Comm_group(mcomm2, &oldgroup); if (merr) MTestPrintError( merr ); ranks[0] = 0; merr = MPI_Group_excl(oldgroup, 1, ranks, &newgroup); if (merr) MTestPrintError( merr ); merr = MPI_Comm_create(mcomm2, newgroup, comm); if (merr) MTestPrintError( merr ); merr = MPI_Group_free(&oldgroup); if (merr) MTestPrintError( merr ); merr = MPI_Group_free(&newgroup); if (merr) MTestPrintError( merr ); interCommName = "Intercomm by splitting MPI_COMM_WORLD then discarding 0 ranks with MPI_Comm_create"; } else { *comm = MPI_COMM_NULL; } break; default: *comm = MPI_COMM_NULL; interCommIdx = -1; break; } if (*comm != MPI_COMM_NULL) { merr = MPI_Comm_size( *comm, &size ); if (merr) MTestPrintError( merr ); merr = MPI_Comm_remote_size( *comm, &remsize ); if (merr) MTestPrintError( merr ); if (size + remsize >= min_size) done = 1; } else { interCommName = "MPI_COMM_NULL"; done = 1; } /* we are only done if all processes are done */ MPI_Allreduce(MPI_IN_PLACE, &done, 1, MPI_INT, MPI_LAND, MPI_COMM_WORLD); /* Advance the comm index whether we are done or not, otherwise we could * spin forever trying to allocate a too-small communicator over and * over again. */ interCommIdx++; if (!done && *comm != MPI_COMM_NULL) { /* avoid leaking communicators */ merr = MPI_Comm_free(comm); if (merr) MTestPrintError(merr); } /* cleanup for common temp objects */ if (mcomm != MPI_COMM_NULL) { merr = MPI_Comm_free(&mcomm); if (merr) MTestPrintError( merr ); } if (mcomm2 != MPI_COMM_NULL) { merr = MPI_Comm_free(&mcomm2); if (merr) MTestPrintError( merr ); } } return interCommIdx; } /* Return the name of an intercommunicator */ const char *MTestGetIntercommName( void ) { return interCommName; } /* Get a communicator of a given minimum size. Both intra and inter communicators are provided */ int MTestGetComm( MPI_Comm *comm, int min_size ) { int idx=0; static int getinter = 0; if (!getinter) { idx = MTestGetIntracomm( comm, min_size ); if (idx == 0) { getinter = 1; } } if (getinter) { int isLeft; idx = MTestGetIntercomm( comm, &isLeft, min_size ); if (idx == 0) { getinter = 0; } } return idx; } /* Free a communicator. It may be called with a predefined communicator or MPI_COMM_NULL */ void MTestFreeComm( MPI_Comm *comm ) { int merr; if (*comm != MPI_COMM_WORLD && *comm != MPI_COMM_SELF && *comm != MPI_COMM_NULL) { merr = MPI_Comm_free( comm ); if (merr) MTestPrintError( merr ); } } /* ------------------------------------------------------------------------ */ void MTestPrintError( int errcode ) { int errclass, slen; char string[MPI_MAX_ERROR_STRING]; MPI_Error_class( errcode, &errclass ); MPI_Error_string( errcode, string, &slen ); printf( "Error class %d (%s)\n", errclass, string ); fflush( stdout ); } void MTestPrintErrorMsg( const char msg[], int errcode ) { int errclass, slen; char string[MPI_MAX_ERROR_STRING]; MPI_Error_class( errcode, &errclass ); MPI_Error_string( errcode, string, &slen ); printf( "%s: Error class %d (%s)\n", msg, errclass, string ); fflush( stdout ); } /* ------------------------------------------------------------------------ */ /* If verbose output is selected and the level is at least that of the value of the verbose flag, then perform printf( format, ... ); */ void MTestPrintfMsg( int level, const char format[], ... ) { va_list list; if (verbose && level >= verbose) { va_start(list,format); vprintf( format, list ); va_end(list); fflush(stdout); } } /* Fatal error. Report and exit */ void MTestError( const char *msg ) { fprintf( stderr, "%s\n", msg ); fflush( stderr ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } /* ------------------------------------------------------------------------ */ static void MTestResourceSummary( FILE *fp ) { #ifdef HAVE_GETRUSAGE struct rusage ru; static int pfThreshold = -2; int doOutput = 1; if (getrusage( RUSAGE_SELF, &ru ) == 0) { /* There is an option to generate output only when a resource exceeds a threshold. To date, only page faults supported. */ if (pfThreshold == -2) { char *p = getenv("MPITEST_RUSAGE_PF"); pfThreshold = -1; if (p) { pfThreshold = strtol( p, 0, 0 ); } } if (pfThreshold > 0) { doOutput = ru.ru_minflt > pfThreshold; } if (doOutput) { /* Cast values to long in case some system has defined them as another integer type */ fprintf( fp, "RUSAGE: max resident set = %ldKB\n", (long)ru.ru_maxrss ); fprintf( fp, "RUSAGE: page faults = %ld : %ld\n", (long)ru.ru_minflt, (long)ru.ru_majflt ); /* Not every Unix provides useful information for the xxrss fields */ fprintf( fp, "RUSAGE: memory in text/data/stack = %ld : %ld : %ld\n", (long)ru.ru_ixrss, (long)ru.ru_idrss, (long)ru.ru_isrss ); fprintf( fp, "RUSAGE: I/O in and out = %ld : %ld\n", (long)ru.ru_inblock, (long)ru.ru_oublock ); fprintf( fp, "RUSAGE: context switch = %ld : %ld\n", (long)ru.ru_nvcsw, (long)ru.ru_nivcsw ); } } else { fprintf( fp, "RUSAGE: return error %d\n", errno ); } #endif } /* ------------------------------------------------------------------------ */ #ifdef HAVE_MPI_WIN_CREATE /* * Create MPI Windows */ static int win_index = 0; static const char *winName; /* Use an attribute to remember the type of memory allocation (static, malloc, or MPI_Alloc_mem) */ static int mem_keyval = MPI_KEYVAL_INVALID; int MTestGetWin( MPI_Win *win, int mustBePassive ) { static char actbuf[1024]; static char *pasbuf; char *buf; int n, rank, merr; MPI_Info info; if (mem_keyval == MPI_KEYVAL_INVALID) { /* Create the keyval */ merr = MPI_Win_create_keyval( MPI_WIN_NULL_COPY_FN, MPI_WIN_NULL_DELETE_FN, &mem_keyval, 0 ); if (merr) MTestPrintError( merr ); } switch (win_index) { case 0: /* Active target window */ merr = MPI_Win_create( actbuf, 1024, 1, MPI_INFO_NULL, MPI_COMM_WORLD, win ); if (merr) MTestPrintError( merr ); winName = "active-window"; merr = MPI_Win_set_attr( *win, mem_keyval, (void *)0 ); if (merr) MTestPrintError( merr ); break; case 1: /* Passive target window */ merr = MPI_Alloc_mem( 1024, MPI_INFO_NULL, &pasbuf ); if (merr) MTestPrintError( merr ); merr = MPI_Win_create( pasbuf, 1024, 1, MPI_INFO_NULL, MPI_COMM_WORLD, win ); if (merr) MTestPrintError( merr ); winName = "passive-window"; merr = MPI_Win_set_attr( *win, mem_keyval, (void *)2 ); if (merr) MTestPrintError( merr ); break; case 2: /* Active target; all windows different sizes */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); n = rank * 64; if (n) buf = (char *)malloc( n ); else buf = 0; merr = MPI_Win_create( buf, n, 1, MPI_INFO_NULL, MPI_COMM_WORLD, win ); if (merr) MTestPrintError( merr ); winName = "active-all-different-win"; merr = MPI_Win_set_attr( *win, mem_keyval, (void *)1 ); if (merr) MTestPrintError( merr ); break; case 3: /* Active target, no locks set */ merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (merr) MTestPrintError( merr ); n = rank * 64; if (n) buf = (char *)malloc( n ); else buf = 0; merr = MPI_Info_create( &info ); if (merr) MTestPrintError( merr ); merr = MPI_Info_set( info, (char*)"nolocks", (char*)"true" ); if (merr) MTestPrintError( merr ); merr = MPI_Win_create( buf, n, 1, info, MPI_COMM_WORLD, win ); if (merr) MTestPrintError( merr ); merr = MPI_Info_free( &info ); if (merr) MTestPrintError( merr ); winName = "active-nolocks-all-different-win"; merr = MPI_Win_set_attr( *win, mem_keyval, (void *)1 ); if (merr) MTestPrintError( merr ); break; default: win_index = -1; } win_index++; return win_index; } /* Return a pointer to the name associated with a window object */ const char *MTestGetWinName( void ) { return winName; } /* Free the storage associated with a window object */ void MTestFreeWin( MPI_Win *win ) { void *addr; int flag, merr; merr = MPI_Win_get_attr( *win, MPI_WIN_BASE, &addr, &flag ); if (merr) MTestPrintError( merr ); if (!flag) { MTestError( "Could not get WIN_BASE from window" ); } if (addr) { void *val; merr = MPI_Win_get_attr( *win, mem_keyval, &val, &flag ); if (merr) MTestPrintError( merr ); if (flag) { if (val == (void *)1) { free( addr ); } else if (val == (void *)2) { merr = MPI_Free_mem( addr ); if (merr) MTestPrintError( merr ); } /* if val == (void *)0, then static data that must not be freed */ } } merr = MPI_Win_free(win); if (merr) MTestPrintError( merr ); } static void MTestRMACleanup( void ) { if (mem_keyval != MPI_KEYVAL_INVALID) { MPI_Win_free_keyval( &mem_keyval ); } } #else static void MTestRMACleanup( void ) {} #endif SimGrid-3.11/teshsuite/smpi/mpich3-test/testlist000644 001750 001750 00000000270 12342443666 020760 0ustar00cici000000 000000 # The next item ensures that the support routines are built first !util:all attr #basic coll comm datatype #errhan group #info init #mpi_t pt2pt # #spawn topo #perf #io f77 #cxx # # SimGrid-3.11/teshsuite/smpi/mpich3-test/init/000755 001750 001750 00000000000 12342443666 020126 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/init/version.c000644 001750 001750 00000001370 12342443662 021754 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" int main( int argc, char *argv[] ) { int errs = 0; int majversion, subversion; MTest_Init( &argc, &argv ); MPI_Get_version( &majversion, &subversion ); if (majversion != MPI_VERSION) { errs++; printf( "Major version is %d but is %d in the mpi.h file\n", majversion, MPI_VERSION ); } if (subversion != MPI_SUBVERSION) { errs++; printf( "Minor version is %d but is %d in the mpi.h file\n", subversion, MPI_SUBVERSION ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/init/testlist000644 001750 001750 00000000332 12342443666 021722 0ustar00cici000000 000000 exitst1 2 resultTest=TestStatus exitst2 4 resultTest=TestStatus initstat 1 #timeout 2 resultTest=TestTimeout timeLimit=10 version 1 finalized 1 #needs PMPI_Comm_free_keyval #attrself 1 library_version 1 mpiversion=3.0 SimGrid-3.11/teshsuite/smpi/mpich3-test/init/timeout.c000644 001750 001750 00000001041 12342443662 021750 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" /* This is a program that tests the ability of mpiexec to timeout a process after no more than 3 minutes. By default, it will run for 5 minutes */ int main( int argc, char *argv[] ) { double t1; double deltaTime = 300; MPI_Init( &argc, &argv ); t1 = MPI_Wtime(); while (MPI_Wtime() - t1 < deltaTime) ; MPI_Finalize( ); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/init/attrself.c000644 001750 001750 00000007027 12342443662 022120 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2009 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" /* static char MTestDescrip[] = "Test creating and inserting attributes in \ different orders to ensure that the list management code handles all cases."; */ int checkAttrs( MPI_Comm, int, int [], int [] ); int delete_fn( MPI_Comm, int, void *, void *); #define NKEYS 5 static int key[NKEYS]; /* Keys in creation order */ static int keyorder[NKEYS]; /* Index (into key) of keys in order added to comm (key[keyorder[0]] is first set) */ static int nkeys = 0; static int ncall = 0; static int errs = 0; /* * Test that attributes on comm self are deleted in LIFO order */ int main( int argc, char *argv[] ) { int attrval[10]; int wrank, i; MPI_Comm comm; MPI_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); comm = MPI_COMM_SELF; /* Create key values */ for (nkeys=0; nkeys= nkeys) { printf( "delete function called too many times!\n" ); errs++; } /* As of MPI 2.2, the order of deletion of attributes on MPI_COMM_SELF is defined */ if (MPI_VERSION > 2 || (MPI_VERSION == 2 && MPI_SUBVERSION >= 2)) { if (keyval != key[keyorder[nkeys-1-ncall]]) { printf( "Expected key # %d but found key with value %d\n", keyorder[nkeys-1-ncall], keyval ); errs++; } } ncall++; return MPI_SUCCESS; } /* int checkNoAttrs( MPI_Comm comm, int n, int lkey[] ) { int lerrs = 0; int i, flag, *val_p; for (i=0; i #include "mpitest.h" static int verbose = 0; int main(int argc, char *argv[]) { int errs = 0, resultlen = -1; char version[MPI_MAX_LIBRARY_VERSION_STRING]; MTest_Init(&argc, &argv); MPI_Get_library_version(version, &resultlen); if (resultlen < 0) { errs++; printf("Resultlen is %d\n", resultlen); } else { if (verbose) printf("%s\n", version); } MTest_Finalize(errs); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/init/finalized.c000644 001750 001750 00000005367 12342443662 022246 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include /* FIXME: This test program assumes that MPI_Error_string will work even if MPI is not initialized. That is not guaranteed. */ /* Normally, when checking for error returns from MPI calls, you must ensure that the error handler on the relevant object (communicator, file, or window) has been set to MPI_ERRORS_RETURN. The tests in this program are a special case, as either a failure or an abort will indicate a problem */ int main( int argc, char *argv[] ) { int error; int flag; char err_string[1024]; int length = 1024; int rank; flag = 0; error = MPI_Finalized(&flag); if (error != MPI_SUCCESS) { MPI_Error_string(error, err_string, &length); printf("MPI_Finalized failed: %s\n", err_string); fflush(stdout); return error; } if (flag) { printf("MPI_Finalized returned true before MPI_Init.\n"); return -1; } error = MPI_Init(&argc, &argv); if (error != MPI_SUCCESS) { MPI_Error_string(error, err_string, &length); printf("MPI_Init failed: %s\n", err_string); fflush(stdout); return error; } error = MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (error != MPI_SUCCESS) { MPI_Error_string(error, err_string, &length); printf("MPI_Comm_rank failed: %s\n", err_string); fflush(stdout); MPI_Abort(MPI_COMM_WORLD, error); return error; } flag = 0; error = MPI_Finalized(&flag); if (error != MPI_SUCCESS) { MPI_Error_string(error, err_string, &length); printf("MPI_Finalized failed: %s\n", err_string); fflush(stdout); MPI_Abort(MPI_COMM_WORLD, error); return error; } if (flag) { printf("MPI_Finalized returned true before MPI_Finalize.\n"); fflush(stdout); MPI_Abort(MPI_COMM_WORLD, error); return -1; } error = MPI_Barrier(MPI_COMM_WORLD); if (error != MPI_SUCCESS) { MPI_Error_string(error, err_string, &length); printf("MPI_Barrier failed: %s\n", err_string); fflush(stdout); MPI_Abort(MPI_COMM_WORLD, error); return error; } error = MPI_Finalize(); if (error != MPI_SUCCESS) { MPI_Error_string(error, err_string, &length); printf("MPI_Finalize failed: %s\n", err_string); fflush(stdout); return error; } flag = 0; error = MPI_Finalized(&flag); if (error != MPI_SUCCESS) { MPI_Error_string(error, err_string, &length); printf("MPI_Finalized failed: %s\n", err_string); fflush(stdout); return error; } if (!flag) { printf("MPI_Finalized returned false after MPI_Finalize.\n"); return -1; } if (rank == 0) { printf(" No Errors\n"); } return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/init/exitst1.c000644 001750 001750 00000000611 12342443662 021665 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" /* * This is a special test to check that mpiexec handles zero/non-zero * return status from an application */ int main( int argc, char *argv[] ) { MPI_Init( 0, 0 ); MPI_Finalize( ); return 1; } SimGrid-3.11/teshsuite/smpi/mpich3-test/init/initstat.c000644 001750 001750 00000001453 12342443662 022130 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" int main( int argc, char *argv[] ) { int errs = 0; int provided, flag, claimed; /* MTest_Init( &argc, &argv ); */ MPI_Init_thread( &argc, &argv, MPI_THREAD_MULTIPLE, &provided ); MPI_Is_thread_main( &flag ); if (!flag) { errs++; printf( "This thread called init_thread but Is_thread_main gave false\n" ); } MPI_Query_thread( &claimed ); if (claimed != provided) { errs++; printf( "Query thread gave thread level %d but Init_thread gave %d\n", claimed, provided ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/init/exitst2.c000644 001750 001750 00000001011 12342443662 021661 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" /* * This is a special test to check that mpiexec handles zero/non-zero * return status from an application. In this case, each process * returns a different return status */ int main( int argc, char *argv[] ) { int rank; MPI_Init( 0, 0 ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Finalize( ); return rank; } SimGrid-3.11/teshsuite/smpi/mpich3-test/init/exitst3.c000644 001750 001750 00000001177 12342443662 021677 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" /* * This is a special test to check that mpiexec handles the death of * some processes without an Abort or clean exit */ int main( int argc, char *argv[] ) { int rank, size; MPI_Init( 0, 0 ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Barrier( MPI_COMM_WORLD ); if (rank == size-1) { /* Cause some processes to exit */ int *p =0 ; *p = rank; } MPI_Finalize( ); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/init/CMakeLists.txt000644 001750 001750 00000003736 12342443654 022674 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include/") # add_executable(attrself attrself.c) add_executable(exitst1 exitst1.c) add_executable(exitst2 exitst2.c) # add_executable(exitst3 exitst3.c) add_executable(finalized finalized.c) add_executable(initstat initstat.c) add_executable(library_version library_version.c) # add_executable(timeout timeout.c) add_executable(version version.c) # target_link_libraries(attrself simgrid mtest_c) target_link_libraries(exitst1 simgrid mtest_c) target_link_libraries(exitst2 simgrid mtest_c) # target_link_libraries(exitst3 simgrid mtest_c) target_link_libraries(finalized simgrid mtest_c) target_link_libraries(initstat simgrid mtest_c) target_link_libraries(library_version simgrid mtest_c) # target_link_libraries(timeout simgrid mtest_c) target_link_libraries(version simgrid mtest_c) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/attrself.c ${CMAKE_CURRENT_SOURCE_DIR}/exitst1.c ${CMAKE_CURRENT_SOURCE_DIR}/exitst2.c ${CMAKE_CURRENT_SOURCE_DIR}/exitst3.c ${CMAKE_CURRENT_SOURCE_DIR}/finalized.c ${CMAKE_CURRENT_SOURCE_DIR}/initstat.c ${CMAKE_CURRENT_SOURCE_DIR}/library_version.c ${CMAKE_CURRENT_SOURCE_DIR}/timeout.c ${CMAKE_CURRENT_SOURCE_DIR}/version.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/hostfile000644 001750 001750 00000000366 12342443666 020730 0ustar00cici000000 000000 Tremblay Jupiter Fafard Ginette Bourassa Tremblay Jupiter Fafard Ginette Bourassa Tremblay Jupiter Fafard Ginette Bourassa Tremblay Jupiter Fafard Ginette Bourassa Tremblay Jupiter Fafard Ginette Bourassa Tremblay Jupiter Fafard Ginette Bourassa SimGrid-3.11/teshsuite/smpi/mpich3-test/include/000755 001750 001750 00000000000 12342443666 020606 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/include/mpitest.h000644 001750 001750 00000007031 12342443666 022445 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #ifndef MPITEST_H_INCLUDED #define MPITEST_H_INCLUDED #include "mpitestconf.h" /* * Init and finalize test */ void MTest_Init( int *, char *** ); void MTest_Init_thread( int *, char ***, int, int * ); void MTest_Finalize( int ); void MTestPrintError( int ); void MTestPrintErrorMsg( const char [], int ); void MTestPrintfMsg( int, const char [], ... ); void MTestError( const char [] ); int MTestReturnValue( int ); /* * Utilities */ void MTestSleep( int ); /* * This structure contains the information used to test datatypes * buf is set to null when an MTestDatatype is created; the * InitBuf routine will allocate (if necessary) and initialize * the data. InitBuf may be called multiple times (this is particularly * important for recv bufs), in which case the buffer will only * be allocated if it has not already been created. */ typedef struct _MTestDatatype { MPI_Datatype datatype; void *buf; /* buffer to use in communication */ int count; /* count to use for this datatype */ int isBasic; /* true if the type is predefined */ int printErrors; /* true if errors should be printed (used by the CheckBuf routines) */ /* The following is optional data that is used by some of the derived datatypes */ int stride, nelm, blksize, *index; /* stride, nelm, and blksize are in bytes */ int *displs, basesize; /* displacements are in multiples of base type; basesize is the size of that type*/ void *(*InitBuf)( struct _MTestDatatype * ); void *(*FreeBuf)( struct _MTestDatatype * ); int (*CheckBuf)( struct _MTestDatatype * ); } MTestDatatype; int MTestCheckRecv( MPI_Status *, MTestDatatype * ); int MTestGetDatatypes( MTestDatatype *, MTestDatatype *, int ); void MTestResetDatatypes( void ); void MTestFreeDatatype( MTestDatatype * ); const char *MTestGetDatatypeName( MTestDatatype * ); int MTestGetDatatypeIndex( void ); int MTestGetIntracomm( MPI_Comm *, int ); int MTestGetIntracommGeneral( MPI_Comm *, int, int ); int MTestGetIntercomm( MPI_Comm *, int *, int ); int MTestGetComm( MPI_Comm *, int ); const char *MTestGetIntracommName( void ); const char *MTestGetIntercommName( void ); void MTestFreeComm( MPI_Comm * ); #ifdef HAVE_MPI_WIN_CREATE int MTestGetWin( MPI_Win *, int ); const char *MTestGetWinName( void ); void MTestFreeWin( MPI_Win * ); #endif /* These macros permit overrides via: * make CPPFLAGS='-DMTEST_MPI_VERSION=X -DMTEST_MPI_SUBVERSION=Y' * where X and Y are the major and minor versions of the MPI standard that is * being tested. The override should work similarly if added to the CPPFLAGS at * configure time. */ #ifndef MTEST_MPI_VERSION #define MTEST_MPI_VERSION MPI_VERSION #endif #ifndef MTEST_MPI_SUBVERSION #define MTEST_MPI_SUBVERSION MPI_SUBVERSION #endif /* Makes it easier to conditionally compile test code for a particular minimum * version of the MPI Standard. Right now there is only a MIN flavor but it * would be easy to add MAX or EXACT flavors if they become necessary at some * point. Example usage: ------8<------- #if MTEST_HAVE_MIN_MPI_VERSION(2,2) ... test for some feature that is only available in MPI-2.2 or later ... #endif ------8<------- */ #define MTEST_HAVE_MIN_MPI_VERSION(major_,minor_) \ ((MTEST_MPI_VERSION == (major_) && MTEST_MPI_SUBVERSION >= (minor_)) || \ (MTEST_MPI_VERSION > (major_))) #endif SimGrid-3.11/teshsuite/smpi/mpich3-test/include/mpitestconf.h000644 001750 001750 00000021567 12342443666 023325 0ustar00cici000000 000000 /* include/mpitestconf.h. Generated from mpitestconf.h.in by configure. */ /* include/mpitestconf.h.in. Generated from configure.ac by autoheader. */ /* -*- Mode: C; c-basic-offset:4 ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #ifndef MPITESTCONF_H_INCLUDED #define MPITESTCONF_H_INCLUDED /* Fortran names are lowercase with no trailing underscore */ /* #undef F77_NAME_LOWER */ /* Fortran names are lowercase with two trailing underscores */ #define F77_NAME_LOWER_2USCORE 1 /* Fortran names are lowercase with two trailing underscores in stdcall */ /* #undef F77_NAME_LOWER_2USCORE_STDCALL */ /* Fortran names are lowercase with no trailing underscore in stdcall */ /* #undef F77_NAME_LOWER_STDCALL */ /* Fortran names are lowercase with one trailing underscore */ /* #undef F77_NAME_LOWER_USCORE */ /* Fortran names are lowercase with one trailing underscore in stdcall */ /* #undef F77_NAME_LOWER_USCORE_STDCALL */ /* Fortran names preserve the original case */ /* #undef F77_NAME_MIXED */ /* Fortran names preserve the original case in stdcall */ /* #undef F77_NAME_MIXED_STDCALL */ /* Fortran names preserve the original case with one trailing underscore */ /* #undef F77_NAME_MIXED_USCORE */ /* Fortran names preserve the original case with one trailing underscore in stdcall */ /* #undef F77_NAME_MIXED_USCORE_STDCALL */ /* Fortran names are uppercase */ /* #undef F77_NAME_UPPER */ /* Fortran names are uppercase in stdcall */ /* #undef F77_NAME_UPPER_STDCALL */ /* Define to 1 if the system has the type `double _Complex'. */ #define HAVE_DOUBLE__COMPLEX 1 /* Define to 1 if the system has the type `float _Complex'. */ #define HAVE_FLOAT__COMPLEX 1 /* Define if Fortran is supported */ //#define HAVE_FORTRAN_BINDING 0 /* Define to 1 if you have the `getrusage' function. */ #ifndef WIN32 #define HAVE_GETRUSAGE 1 #endif /* Define if struct hostent contains h_addr_list */ #define HAVE_H_ADDR_LIST 1 /* Define to 1 if you have the header file. */ #define HAVE_INTTYPES_H 1 /* Define if iostream is available */ #define HAVE_IOSTREAM 1 /* Define to 1 if you have the header file. */ /* #undef HAVE_IOSTREAM_H */ /* Define if long double is supported */ #define HAVE_LONG_DOUBLE 1 /* Define to 1 if the system has the type `long double _Complex'. */ #define HAVE_LONG_DOUBLE__COMPLEX 1 /* Define if compiler supports long long */ #define HAVE_LONG_LONG 1 /* Define to 1 if you have the header file. */ #define HAVE_MEMORY_H 1 /* Define if MPI_2COMPLEX is available */ /* #undef HAVE_MPI_2COMPLEX */ /* Define if MPI_2DOUBLE_COMPLEX is available */ /* #undef HAVE_MPI_2DOUBLE_COMPLEX */ /* Define to 1 if you have the `MPI_Init_thread' function. */ /* #undef HAVE_MPI_INIT_THREAD */ /* Define if MPI_INTEGER16 is available */ /* #undef HAVE_MPI_INTEGER16 */ /* Define if MPI-IO (really ROMIO) is included */ //#define HAVE_MPI_IO 1 /* Define if Dynamic Process functionality is available */ #define HAVE_MPI_SPAWN 1 /* Define if MPI_Win_create is available */ //#define HAVE_MPI_WIN_CREATE 1 /* define if the compiler implements namespaces */ #define HAVE_NAMESPACES /**/ /* define if the compiler implements namespace std */ #define HAVE_NAMESPACE_STD /**/ /* Define to 1 if you have the `pthread_barrier_init' function. */ /* #undef HAVE_PTHREAD_BARRIER_INIT */ /* Define to 1 if you have the `pthread_barrier_wait' function. */ /* #undef HAVE_PTHREAD_BARRIER_WAIT */ /* Define to 1 if you have the `pthread_create' function. */ /* #undef HAVE_PTHREAD_CREATE */ /* Define to 1 if you have the header file. */ /* #undef HAVE_PTHREAD_H */ /* Define to 1 if you have the `pthread_yield' function. */ /* #undef HAVE_PTHREAD_YIELD */ /* Define to 1 if you have the header file. */ #define HAVE_STDARG_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STDINT_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STDLIB_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STRINGS_H 1 /* Define to 1 if you have the header file. */ #define HAVE_STRING_H 1 /* Define to 1 if you have the header file. */ #ifndef WIN32 #define HAVE_SYS_RESOURCE_H 1 #endif /* Define to 1 if you have the header file. */ #define HAVE_SYS_STAT_H 1 /* Define to 1 if you have the header file. */ #define HAVE_SYS_TIME_H 1 /* Define to 1 if you have the header file. */ #define HAVE_SYS_TYPES_H 1 /* Define to 1 if you have the header file. */ #define HAVE_UNISTD_H 1 /* Define to 1 if the system has the type `_Bool'. */ #define HAVE__BOOL 1 /* Define if MPI IO uses MPI_Request */ #define MPIO_USES_MPI_REQUEST /**/ /* Name of package */ #define PACKAGE "mpich-testsuite" /* Define to the address where bug reports for this package should be sent. */ #define PACKAGE_BUGREPORT "" /* Define to the full name of this package. */ #define PACKAGE_NAME "mpich-testsuite" /* Define to the full name and version of this package. */ #define PACKAGE_STRING "mpich-testsuite 1.2" /* Define to the one symbol short name of this package. */ #define PACKAGE_TARNAME "mpich-testsuite" /* Define to the home page for this package. */ #define PACKAGE_URL "" /* Define to the version of this package. */ #define PACKAGE_VERSION "1.2" /* POINTERINT_t is a pointer-sized integer */ #define POINTERINT_t int /* The size of `int', as computed by sizeof. */ #define SIZEOF_INT /* The size of `long', as computed by sizeof. */ #define SIZEOF_LONG /* The size of `long long', as computed by sizeof. */ #define SIZEOF_LONG_LONG /* The size of `MPI_Offset', as computed by sizeof. */ #define SIZEOF_MPI_OFFSET /* The size of `short', as computed by sizeof. */ #define SIZEOF_SHORT /* The size of `void *', as computed by sizeof. */ #define SIZEOF_VOID_P /* Define calling convention */ #define STDCALL /* Define to 1 if you have the ANSI C header files. */ #define STDC_HEADERS 1 /* Define if tests with long double complex should be included */ #define USE_LONG_DOUBLE_COMPLEX 1 /* Define if only operations defined in MPI should be tested */ /* #undef USE_STRICT_MPI */ /* Version number of package */ #define VERSION "1.2" /* Define for Solaris 2.5.1 so the uint32_t typedef from , , or is not used. If the typedef were allowed, the #define below would cause a syntax error. */ /* #undef _UINT32_T */ /* Define for Solaris 2.5.1 so the uint64_t typedef from , , or is not used. If the typedef were allowed, the #define below would cause a syntax error. */ /* #undef _UINT64_T */ /* Define for Solaris 2.5.1 so the uint8_t typedef from , , or is not used. If the typedef were allowed, the #define below would cause a syntax error. */ /* #undef _UINT8_T */ /* Define to empty if `const' does not conform to ANSI C. */ /* #undef const */ /* Define to the type of a signed integer type of width exactly 16 bits if such a type exists and the standard includes do not define it. */ /* #undef int16_t */ /* Define to the type of a signed integer type of width exactly 32 bits if such a type exists and the standard includes do not define it. */ /* #undef int32_t */ /* Define to the type of a signed integer type of width exactly 64 bits if such a type exists and the standard includes do not define it. */ /* #undef int64_t */ /* Define to the type of a signed integer type of width exactly 8 bits if such a type exists and the standard includes do not define it. */ /* #undef int8_t */ /* Define to the equivalent of the C99 'restrict' keyword, or to nothing if this is not supported. Do not define if restrict is supported directly. */ #define restrict __restrict /* Work around a bug in Sun C++: it does not support _Restrict or __restrict__, even though the corresponding Sun C compiler ends up with "#define restrict _Restrict" or "#define restrict __restrict__" in the previous line. Perhaps some future version of Sun C++ will work with restrict; if so, hopefully it defines __RESTRICT like Sun C does. */ #if defined __SUNPRO_CC && !defined __RESTRICT # define _Restrict # define __restrict__ #endif /* Define to the type of an unsigned integer type of width exactly 16 bits if such a type exists and the standard includes do not define it. */ /* #undef uint16_t */ /* Define to the type of an unsigned integer type of width exactly 32 bits if such a type exists and the standard includes do not define it. */ /* #undef uint32_t */ /* Define to the type of an unsigned integer type of width exactly 64 bits if such a type exists and the standard includes do not define it. */ /* #undef uint64_t */ /* Define to the type of an unsigned integer type of width exactly 8 bits if such a type exists and the standard includes do not define it. */ /* #undef uint8_t */ #endif SimGrid-3.11/teshsuite/smpi/mpich3-test/checktests000755 001750 001750 00000004273 12342443666 021257 0ustar00cici000000 000000 #! /usr/local/bin/perl $debug = 1; $verbose = 1; $ignoreBogusOutput = 0; $filePattern = "runtests.*.status"; $testsPassed = 0; $testsFailed = 0; foreach $_ (@ARGV) { if (/^--?ignorebogus/) { $ignoreBogusOutput = 1; } else { print STDERR "checktests [ -ignorebogus ]\n"; exit(1); } } open( RESULTS, "ls -1 $filePattern |" ) || die "Cannot list directory using ls -1 $filePattern\n"; while () { chop; $statusFile = $_; $resultsFile = $statusFile; $resultsFile =~ s/\.status/.out/; if ($resultsFile =~ /runtests\.([0-9]+)\.out/) { $count = $1; } else { $count = -1; print STDERR "Unable to determine test number from $resultsFile!\n"; $testsFailed ++; next; } open (SFD, "<$statusFile" ); while () { chop; $testStatus = $_; } close (SFD); if (-s $resultsFile) { open (RFD, "<$resultsFile"); $runLine = ; $sawNoerrors = 0; # Successful output should contain ONLY the line No Errors while () { chop; $outLine = $_; if ($outLine =~ /^\s+No [Ee]rrors\s*$/) { $sawNoerrors = 1; } else { # To filter out output that may be added to STDOUT # by a badly behaved runtime system, you can either # add a specific filter here (preferred) or set the # -ignorebogus option (considered a workaround) # The following is an example that accepts certain # kinds of output once "No Errors" is seen. if ($sawNoerrors) { if ( /^Application [0-9]+ resources: utime .*/) { last; } } if (!$ignoreBogusOutput) { # Any extraneous output is an error $sawNoerrors = 0; } } } close (RFD); if ($sawNoerrors == 1 && $testStatus == 0) { $testsPassed ++; } else { # Test wrote No Errors but then exited with a non-zero status $testsFailed ++; # Output the errors if ($verbose) { print STDOUT "Test $count failed:\n"; print STDOUT "Test status: $testStatus\n"; print STDOUT "Test output:\n"; system ("cat $resultsFile" ); } } } else { print STDERR "No $resultsFile\n" if $debug; $testsFailed ++; } } print "Tests passed: $testsPassed; test failed: $testsFailed\n"; SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/000755 001750 001750 00000000000 12342443666 020776 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/hindexed-zeros.c000644 001750 001750 00000012644 12342443662 024075 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include #include #include "mpi.h" static int verbose = 0; int parse_args(int argc, char **argv); int hindexed_zerotype_test(void); int hindexed_sparsetype_test(void); struct test_struct_1 { int a,b,c,d; }; int main(int argc, char *argv[]) { int err, errs = 0; /* Initialize MPI */ MPI_Init(&argc, &argv); parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); err = hindexed_zerotype_test(); if (verbose && err) fprintf(stderr, "error in hindexed_zerotype_test\n"); errs += err; err = hindexed_sparsetype_test(); if (verbose && err) fprintf(stderr, "error in hindexed_sparsetype_test\n"); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } /* tests with an hindexed type with all zero length blocks */ int hindexed_zerotype_test(void) { int err, errs = 0; int count, elements; MPI_Datatype mytype; MPI_Request request; MPI_Status status; int blks[] = { 0, 0, 0 }; MPI_Aint disps[] = { 0, 4, 16 }; err = MPI_Type_hindexed(3, blks, disps, MPI_INT, &mytype); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Type_hindexed returned error\n"); } } MPI_Type_commit(&mytype); err = MPI_Irecv(NULL, 2, mytype, 0, 0, MPI_COMM_SELF, &request); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Irecv returned error\n"); } } err = MPI_Send(NULL, 1, mytype, 0, 0, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Send returned error\n"); } } err = MPI_Wait(&request, &status); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Wait returned error\n"); } } /* verify count and elements */ err = MPI_Get_count(&status, mytype, &count); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Get_count returned error\n"); } } if (count != 0) { errs++; if (verbose) { fprintf(stderr, "count = %d; should be 0\n", count); } } err = MPI_Get_elements(&status, mytype, &elements); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Get_elements returned error\n"); } } if (elements != 0) { errs++; if (verbose) { fprintf(stderr, "elements = %d; should be 0\n", elements); } } // MPI_Type_free(&mytype); return errs; } /* tests a short receive into a sparse hindexed type with a zero * length block in it. sort of eccentric, but we've got the basic * stuff covered with other tests. */ int hindexed_sparsetype_test(void) { int err, errs = 0; int i, count, elements; MPI_Datatype mytype; MPI_Request request; MPI_Status status; int sendbuf[6] = { 1, 2, 3, 4, 5, 6 }; int recvbuf[16]; int correct[16] = { 1, -2, 4, -4, 2, 3, 5, -8, -9, -10, 6, -12, -13, -14, -15, -16 }; int blks[] = { 1, 0, 2, 1 }; MPI_Aint disps[] = { 0, 1*sizeof(int), 4*sizeof(int), 2*sizeof(int) }; err = MPI_Type_hindexed(4, blks, disps, MPI_INT, &mytype); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Type_hindexed returned error\n"); } } MPI_Type_commit(&mytype); for (i=0; i < 16; i++) recvbuf[i] = -(i+1); err = MPI_Irecv(recvbuf, 2, mytype, 0, 0, MPI_COMM_SELF, &request); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Irecv returned error\n"); } } err = MPI_Send(sendbuf, 6, MPI_INT, 0, 0, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Send returned error\n"); } } err = MPI_Wait(&request, &status); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Wait returned error\n"); } } /* verify data */ for (i=0; i < 16; i++) { if (recvbuf[i] != correct[i]) { errs++; if (verbose) { fprintf(stderr, "recvbuf[%d] = %d; should be %d\n", i, recvbuf[i], correct[i]); } } } /* verify count and elements */ err = MPI_Get_count(&status, mytype, &count); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Get_count returned error\n"); } } if (count != MPI_UNDEFINED) { errs++; if (verbose) { fprintf(stderr, "count = %d; should be MPI_UNDEFINED (%d)\n", count, MPI_UNDEFINED); } } err = MPI_Get_elements(&status, mytype, &elements); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Get_elements returned error\n"); } } if (elements != 6) { errs++; if (verbose) { fprintf(stderr, "elements = %d; should be 6\n", elements); } } // MPI_Type_free(&mytype); return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/triangular-pack.c000644 001750 001750 00000004423 12342443662 024225 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include #include #include "mpi.h" #include "mpitest.h" /* helper functions */ int parse_args(int argc, char **argv); static int verbose = 0; int main(int argc, char *argv[]) { /* Variable declarations */ int a[100][100], b[100][100]; int disp[100], block[100]; MPI_Datatype ltype; int bufsize, position = 0; void *buffer; int i, j, errs = 0; /* Initialize a to some known values and zero out b. */ for(i = 0; i < 100; i++) { for(j = 0; j < 100; j++) { a[i][j] = 1000*i + j; b[i][j] = 0; } } /* Initialize MPI */ MTest_Init( &argc, &argv ); parse_args(argc, argv); for(i = 0; i < 100; i++) { /* Fortran version has disp(i) = 100*(i-1) + i and block(i) = 100-i. */ /* This code here is wrong. It compacts everything together, * which isn't what we want. * What we want is to put the lower triangular values into b and leave * the rest of it unchanged, right? */ block[i] = i+1; disp[i] = 100*i; } /* Create datatype for lower triangular part. */ MPI_Type_indexed(100, block, disp, MPI_INT, <ype); MPI_Type_commit(<ype); /* Pack it. */ MPI_Pack_size(1, ltype, MPI_COMM_WORLD, &bufsize); buffer = (void *) malloc((unsigned) bufsize); MPI_Pack( a, 1, ltype, buffer, bufsize, &position, MPI_COMM_WORLD ); /* Unpack the buffer into b. */ position = 0; MPI_Unpack(buffer, bufsize, &position, b, 1, ltype, MPI_COMM_WORLD); for(i = 0; i < 100; i++) { for(j = 0; j < 100; j++) { if (j > i && b[i][j] != 0) { errs++; if (verbose) fprintf(stderr, "b[%d][%d] = %d; should be %d\n", i, j, b[i][j], 0); } else if (j <= i && b[i][j] != 1000*i + j) { errs++; if (verbose) fprintf(stderr, "b[%d][%d] = %d; should be %d\n", i, j, b[i][j], 1000*i + j); } } } MTest_Finalize( errs ); MPI_Finalize(); return 0; } int parse_args(int argc, char **argv) { int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/subarray.c000644 001750 001750 00000003421 12342443662 022766 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include "mpi.h" #define X 64 #define Y 8 #define Z 512 double array[X][Y][Z]; int main(int argc, char *argv[]) { int myrank; MPI_Datatype subarray; int array_size[] = {X, Y, Z}; int array_subsize[] = {X/2, Y/2, Z}; int array_start[] = {0, 0, 0}; int i, j, k; int errs = 0; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &myrank); for (i = 0; i < X; ++i) { for (j = 0; j < Y; ++j) { for (k = 0; k < Z; ++k) { if (myrank == 0) array[i][j][k] = 2.0; else array[i][j][k] = -2.0; } } } MPI_Type_create_subarray(3, array_size, array_subsize, array_start, MPI_ORDER_C, MPI_DOUBLE, &subarray); MPI_Type_commit(&subarray); if(myrank == 0) MPI_Send(array, 1, subarray, 1, 0, MPI_COMM_WORLD); else { MPI_Recv(array, 1, subarray, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE); for (i = array_start[0]; i < array_subsize[0]; ++i) { for (j = array_start[1]; j < array_subsize[1]; ++j) { for (k = array_start[2]; k < array_subsize[2]; ++k) { if (array[i][j][k] != 2.0) ++errs; } } } } MPI_Type_free(&subarray); MPI_Allreduce(MPI_IN_PLACE, &errs, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD); if (myrank == 0) { if (errs) printf("Found %d errors\n", errs); else printf(" No Errors\n"); } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/struct-no-real-types.c000644 001750 001750 00000005641 12342443662 025165 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif /* The default behavior of the test routines should be to briefly indicate the cause of any errors - in this test, that means that verbose needs to be set. Verbose should turn on output that is independent of error levels. */ static int verbose = 1; /* tests */ int no_real_types_test(void); /* helper functions */ int parse_args(int argc, char **argv); int main(int argc, char **argv) { int err, errs = 0; MTest_Init(&argc, &argv); parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = no_real_types_test(); if (err && verbose) fprintf(stderr, "%d errors in blockindexed test.\n", err); errs += err; MTest_Finalize( errs ); MPI_Finalize(); return 0; } /* no_real_types_test() * * Tests behavior with an empty struct type * * Returns the number of errors encountered. */ int no_real_types_test(void) { int err, errs = 0; int count = 1; int len = 1; MPI_Aint disp = 10; MPI_Datatype type = MPI_LB; MPI_Datatype newtype; int size; MPI_Aint extent; err = MPI_Type_create_struct(count, &len, &disp, &type, &newtype); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating struct type no_real_types_test()\n"); } MTestPrintError( err ); errs++; } err = MPI_Type_size(newtype, &size); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type size in no_real_types_test()\n"); } MTestPrintError( err ); errs++; } if (size != 0) { if (verbose) { fprintf(stderr, "error: size != 0 in no_real_types_test()\n"); } errs++; } err = MPI_Type_extent(newtype, &extent); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type extent in no_real_types_test()\n"); } MTestPrintError( err ); errs++; } if (extent != -10) { if (verbose) { fprintf(stderr, "error: extent is %ld but should be -10 in no_real_types_test()\n", (long) extent ); fprintf( stderr, "type map is { (LB,10) }, so UB is 0 and extent is ub-lb\n" ); } errs++; } MPI_Type_free( &newtype ); return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/struct-verydeep.c000644 001750 001750 00000011513 12342443662 024304 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2009 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* Regression test for MPICH trac ticket #972, originally written by * Rob Latham as a simplification of a type * encountered by the HDF5 library. * * Should be run with 1 process. */ #include #include "mpi.h" /* uncomment to use debugging routine in MPICH extern int MPIDU_Datatype_debug(MPI_Datatype type, int depth); */ int makeHDF5type0(MPI_Datatype *type); int makeHDF5type0(MPI_Datatype *type) { MPI_Datatype ctg, vect, structype, vec2, structype2, vec3, structype3, vec4, structype4, vec5; int b[3]; MPI_Aint d[3]; MPI_Datatype t[3]; MPI_Type_contiguous(4, MPI_BYTE, &ctg); MPI_Type_vector(1, 5, 1, ctg, &vect); b[0] = b[1] = b[2] = 1; d[0] = 0; d[1] = 0; d[2] = 40; t[0] = MPI_LB; t[1] = vect; t[2] = MPI_UB; MPI_Type_create_struct(3, b, d, t, &structype); MPI_Type_vector(1, 5, 1, structype, &vec2); b[0] = b[1] = b[2] = 1; d[0] = 0; d[1] = 2000; d[2] = 400; t[0] = MPI_LB; t[1] = vec2; t[2] = MPI_UB; MPI_Type_create_struct(3, b, d, t, &structype2); MPI_Type_vector(1, 5, 1, structype2, &vec3); b[0] = b[1] = b[2] = 1; d[0] = 0; d[1] = 0; d[2] = 4000; t[0] = MPI_LB; t[1] = vec3; t[2] = MPI_UB; MPI_Type_create_struct(3, b, d, t, &structype3); MPI_Type_vector(1, 5, 1, structype3, &vec4); b[0] = b[1] = b[2] = 1; d[0] = 0; d[1] = 0; d[2] = 40000; t[0] = MPI_LB; t[1] = vec4; t[2] = MPI_UB; MPI_Type_create_struct(3, b, d, t, &structype4); MPI_Type_vector(1, 1, 1, structype4, &vec5); b[0] = b[1] = b[2] = 1; d[0] = 0; d[1] = 160000; d[2] = 200000; t[0] = MPI_LB; t[1] = vec5; t[2] = MPI_UB; MPI_Type_create_struct(3, b, d, t, type); MPI_Type_free(&ctg); MPI_Type_free(&vect); MPI_Type_free(&structype); MPI_Type_free(&vec2); MPI_Type_free(&structype2); MPI_Type_free(&vec3); MPI_Type_free(&structype3); MPI_Type_free(&vec4); MPI_Type_free(&structype4); MPI_Type_free(&vec5); MPI_Type_commit(type); return 0; } int makeHDF5type1(MPI_Datatype *type); int makeHDF5type1(MPI_Datatype *type) { MPI_Datatype ctg, vect, structype, vec2, structype2, vec3, structype3, vec4, structype4, vec5; int b[3]; MPI_Aint d[3]; MPI_Datatype t[3]; MPI_Type_contiguous(4, MPI_BYTE, &ctg); MPI_Type_vector(1, 5, 1, ctg, &vect); b[0] = b[1] = b[2] = 1; d[0] = 0; d[1] = 20; d[2] = 40; t[0] = MPI_LB; t[1] = vect; t[2] = MPI_UB; MPI_Type_create_struct(3, b, d, t, &structype); MPI_Type_vector(1, 5, 1, structype, &vec2); b[0] = b[1] = b[2] = 1; d[0] = 0; d[1] = 0; d[2] = 400; t[0] = MPI_LB; t[1] = vec2; t[2] = MPI_UB; MPI_Type_create_struct(3, b, d, t, &structype2); MPI_Type_vector(1, 5, 1, structype2, &vec3); b[0] = b[1] = b[2] = 1; d[0] = 0; d[1] = 0; d[2] = 4000; t[0] = MPI_LB; t[1] = vec3; t[2] = MPI_UB; MPI_Type_create_struct(3, b, d, t, &structype3); MPI_Type_vector(1, 5, 1, structype3, &vec4); b[0] = b[1] = b[2] = 1; d[0] = 0; d[1] = 0; d[2] = 40000; t[0] = MPI_LB; t[1] = vec4; t[2] = MPI_UB; MPI_Type_create_struct(3, b, d, t, &structype4); MPI_Type_vector(1, 1, 1, structype4, &vec5); b[0] = b[1] = b[2] = 1; d[0] = 0; d[1] = 160000; d[2] = 200000; t[0] = MPI_LB; t[1] = vec5; t[2] = MPI_UB; MPI_Type_create_struct(3, b, d, t, type); MPI_Type_free(&ctg); MPI_Type_free(&vect); MPI_Type_free(&structype); MPI_Type_free(&vec2); MPI_Type_free(&structype2); MPI_Type_free(&vec3); MPI_Type_free(&structype3); MPI_Type_free(&vec4); MPI_Type_free(&structype4); MPI_Type_free(&vec5); MPI_Type_commit(type); return 0; } int makeHDF5type(MPI_Datatype *type); int makeHDF5type(MPI_Datatype *type) { int i; #define NTYPES 2 int blocklens[NTYPES]; MPI_Aint disps[NTYPES]; MPI_Datatype types[NTYPES]; makeHDF5type0(&(types[0])); makeHDF5type1(&(types[1])); for (i=0; i< NTYPES; i++) { blocklens[i] = 1; disps[i] = 0; } MPI_Type_create_struct(NTYPES, blocklens, disps, types, type); MPI_Type_commit(type); for(i=0; i #include #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 0; int short_int_pack_test(void); /* helper functions */ int parse_args(int argc, char **argv); static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz); int main(int argc, char *argv[]) { int err, errs = 0; MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */ parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); err = short_int_pack_test(); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } int short_int_pack_test(void) { int i, err, errs = 0; struct shortint { short a; int b; } sibuf[16]; for (i=0; i < 16; i++) { sibuf[i].a = (short) (i * 2); sibuf[i].b = i * 2 + 1; } err = pack_and_unpack((char *) sibuf, 16, MPI_SHORT_INT, sizeof(sibuf)); if (err != 0) { if (verbose) { fprintf(stderr, "error packing/unpacking in short_int_pack_test()\n"); } errs += err; } for (i=0; i < 16; i++) { if (sibuf[i].a != (short) (i * 2)) { err++; if (verbose) { fprintf(stderr, "buf[%d] has invalid short (%d); should be %d\n", i, (int) sibuf[i].a, i * 2); } } if (sibuf[i].b != i * 2 + 1) { err++; if (verbose) { fprintf(stderr, "buf[%d] has invalid int (%d); should be %d\n", i, (int) sibuf[i].b, i * 2 + 1); } } } return errs; } /* pack_and_unpack() * * Perform packing and unpacking of a buffer for the purposes of checking * to see if we are processing a type correctly. Zeros the buffer between * these two operations, so the data described by the type should be in * place upon return but all other regions of the buffer should be zero. * * Parameters: * typebuf - pointer to buffer described by datatype and count that * will be packed and then unpacked into * count, datatype - description of typebuf * typebufsz - size of typebuf; used specifically to zero the buffer * between the pack and unpack steps * */ static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz) { char *packbuf; int err, errs = 0, pack_size, type_size, position; err = MPI_Type_size(datatype, &type_size); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_size call; aborting after %d errors\n", errs); } return errs; } type_size *= count; err = MPI_Pack_size(count, datatype, MPI_COMM_SELF, &pack_size); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Pack_size call; aborting after %d errors\n", errs); } return errs; } packbuf = (char *) malloc(pack_size); if (packbuf == NULL) { errs++; if (verbose) { fprintf(stderr, "error in malloc call; aborting after %d errors\n", errs); } return errs; } position = 0; err = MPI_Pack(typebuf, count, datatype, packbuf, type_size, &position, MPI_COMM_SELF); if (position != type_size) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (pack)\n", position, type_size); } memset(typebuf, 0, typebufsz); position = 0; err = MPI_Unpack(packbuf, type_size, &position, typebuf, count, datatype, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Unpack call; aborting after %d errors\n", errs); } return errs; } free(packbuf); if (position != type_size) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (unpack)\n", position, type_size); } return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/struct-zero-count.c000644 001750 001750 00000005117 12342443662 024571 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 0; /* tests */ int builtin_struct_test(void); /* helper functions */ int parse_args(int argc, char **argv); int main(int argc, char **argv) { int err, errs = 0; MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */ parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = builtin_struct_test(); if (err && verbose) fprintf(stderr, "%d errors in builtin struct test.\n", err); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } /* builtin_struct_test() * * Tests behavior with a zero-count struct of builtins. * * Returns the number of errors encountered. */ int builtin_struct_test(void) { int err, errs = 0; int count = 0; MPI_Datatype newtype; int size; MPI_Aint extent; err = MPI_Type_create_struct(count, (int *) 0, (MPI_Aint *) 0, (MPI_Datatype *) 0, &newtype); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating struct type in builtin_struct_test()\n"); } errs++; } err = MPI_Type_size(newtype, &size); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type size in builtin_struct_test()\n"); } errs++; } if (size != 0) { if (verbose) { fprintf(stderr, "error: size != 0 in builtin_struct_test()\n"); } errs++; } err = MPI_Type_extent(newtype, &extent); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type extent in builtin_struct_test()\n"); } errs++; } if (extent != 0) { if (verbose) { fprintf(stderr, "error: extent != 0 in builtin_struct_test()\n"); } errs++; } MPI_Type_free( &newtype ); return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/indexed-misc.c000644 001750 001750 00000046122 12342443662 023514 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif #include #include static int verbose = 1; #define check(cond_) \ do { \ if (!(cond_)) { \ if (verbose) { \ fprintf(stderr, "condition '%s' does not hold, at line %d\n", #cond_, __LINE__); \ } \ errs += 1; \ } \ } while (0) #define check_err(err_, what_failed_) \ do { \ if (err_) { \ if (verbose) { \ fprintf(stderr, "error: %s, at line %d\n", (what_failed_), __LINE__); \ } \ errs += (err_); \ } \ } while (0) /* tests */ int indexed_contig_test(void); int indexed_zeroblock_first_test(void); int indexed_zeroblock_middle_test(void); int indexed_zeroblock_last_test(void); int indexed_contig_leading_zero_test(void); int indexed_same_lengths(void); /* helper functions */ int parse_args(int argc, char **argv); static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz); int main(int argc, char **argv) { int err, errs = 0; MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */ parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = indexed_contig_test(); if (err && verbose) fprintf(stderr, "%d errors in indexed_contig_test.\n", err); errs += err; err = indexed_zeroblock_first_test(); if (err && verbose) fprintf(stderr, "%d errors in indexed_zeroblock_first_test.\n", err); errs += err; err = indexed_zeroblock_middle_test(); if (err && verbose) fprintf(stderr, "%d errors in indexed_zeroblock_middle_test.\n", err); errs += err; err = indexed_zeroblock_last_test(); if (err && verbose) fprintf(stderr, "%d errors in indexed_zeroblock_last_test.\n", err); errs += err; err = indexed_contig_leading_zero_test(); if (err && verbose) fprintf(stderr, "%d errors in indexed_contig_leading_zero_test.\n", err); errs += err; err = indexed_same_lengths(); if (err && verbose) fprintf(stderr, "%d errors in indexed_contig_leading_zero_test.\n", err); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } int indexed_zeroblock_first_test(void) { int err, errs = 0; MPI_Datatype type; int len[3] = { 0, 1, 1 }; int disp[3] = { 0, 1, 4 }; MPI_Aint lb, ub; err = MPI_Type_indexed(3, len, disp, MPI_INT, &type); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating indexed type in indexed_zeroblock_first_test()\n"); } errs += 1; } MPI_Type_lb(type, &lb); if (lb != sizeof(int)) { if (verbose) { fprintf(stderr, "lb mismatch; is %d, should be %d\n", (int) lb, (int) sizeof(int)); } errs++; } MPI_Type_ub(type, &ub); if (ub != 5 * sizeof(int)) { if (verbose) { fprintf(stderr, "ub mismatch; is %d, should be %d\n", (int) ub, (int) (5 * sizeof(int))); } errs++; } MPI_Type_free( &type ); return errs; } int indexed_zeroblock_middle_test(void) { int err, errs = 0; MPI_Datatype type; int len[3] = { 1, 0, 1 }; int disp[3] = { 1, 2, 4 }; MPI_Aint lb, ub; err = MPI_Type_indexed(3, len, disp, MPI_INT, &type); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating indexed type in indexed_zeroblock_middle_test()\n"); } errs += 1; } MPI_Type_lb(type, &lb); if (lb != sizeof(int)) { if (verbose) { fprintf(stderr, "lb mismatch; is %d, should be %d\n", (int) lb, (int) sizeof(int)); } errs++; } MPI_Type_ub(type, &ub); if (ub != 5 * sizeof(int)) { if (verbose) { fprintf(stderr, "ub mismatch; is %d, should be %d\n", (int) ub, (int) (5 * sizeof(int))); } errs++; } MPI_Type_free( &type ); return errs; } int indexed_zeroblock_last_test(void) { int err, errs = 0; MPI_Datatype type; int len[3] = { 1, 1, 0 }; int disp[3] = { 1, 4, 8 }; MPI_Aint lb, ub; err = MPI_Type_indexed(3, len, disp, MPI_INT, &type); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating indexed type in indexed_zeroblock_last_test()\n"); } errs += 1; } MPI_Type_lb(type, &lb); if (lb != sizeof(int)) { if (verbose) { fprintf(stderr, "lb mismatch; is %d, should be %d\n", (int) lb, (int) sizeof(int)); } errs++; } MPI_Type_ub(type, &ub); if (ub != 5 * sizeof(int)) { if (verbose) { fprintf(stderr, "ub mismatch; is %d, should be %d\n", (int) ub, (int) (5 * sizeof(int))); } errs++; } MPI_Type_free( &type ); return errs; } /* indexed_contig_test() * * Tests behavior with an indexed array that can be compacted but should * continue to be stored as an indexed type. Specifically for coverage. * * Returns the number of errors encountered. */ int indexed_contig_test(void) { int buf[9] = {-1, 1, 2, 3, -2, 4, 5, -3, 6}; int err, errs = 0; int i, count = 5; int blklen[] = { 1, 2, 1, 1, 1 }; int disp[] = { 1, 2, 5, 6, 8 }; MPI_Datatype newtype; int size, int_size; err = MPI_Type_indexed(count, blklen, disp, MPI_INT, &newtype); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating indexed type in indexed_contig_test()\n"); } errs++; } MPI_Type_size(MPI_INT, &int_size); err = MPI_Type_size(newtype, &size); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type size in indexed_contig_test()\n"); } errs++; } if (size != 6 * int_size) { if (verbose) { fprintf(stderr, "error: size != 6 * int_size in indexed_contig_test()\n"); } errs++; } MPI_Type_commit(&newtype); err = pack_and_unpack((char *) buf, 1, newtype, 9 * sizeof(int)); if (err != 0) { if (verbose) { fprintf(stderr, "error packing/unpacking in indexed_contig_test()\n"); } errs += err; } for (i=0; i < 9; i++) { int goodval; switch(i) { case 1: goodval = 1; break; case 2: goodval = 2; break; case 3: goodval = 3; break; case 5: goodval = 4; break; case 6: goodval = 5; break; case 8: goodval = 6; break; default: goodval = 0; /* pack_and_unpack() zeros before unpack */ break; } if (buf[i] != goodval) { errs++; if (verbose) fprintf(stderr, "buf[%d] = %d; should be %d\n", i, buf[i], goodval); } } MPI_Type_free( &newtype ); return errs; } /* very similar to indexed_zeroblock_first_test, but only has a single contig in * order to catch a particular optimization path in MPICH's * Dataloop_create_indexed routine */ int indexed_contig_leading_zero_test(void) { int err, errs = 0; int i; MPI_Datatype type = MPI_DATATYPE_NULL; MPI_Datatype struct_type = MPI_DATATYPE_NULL; MPI_Datatype types[2]; int len[3] = { 0, 4, 0 }; int disp[3] = { INT_MAX, 2, INT_MAX}; MPI_Aint adisp[3]; MPI_Aint lb, ub; int *buf = NULL; err = MPI_Type_indexed(3, len, disp, MPI_INT, &type); check_err(err, "creating indexed type in indexed_contig_leading_zero_test()"); err = MPI_Type_commit(&type); check_err(err, "committing indexed type in indexed_contig_leading_zero_test()"); MPI_Type_lb(type, &lb); check(lb == 2 * sizeof(int)); MPI_Type_ub(type, &ub); check(ub == 6 * sizeof(int)); /* make sure packing/unpacking works (hits a simple "is_contig" case in * MPICH's pack/unpack routines) */ buf = malloc(10*sizeof(int)); assert(buf != NULL); for (i = 0; i < 10; ++i) { buf[i] = i + 1; } err = pack_and_unpack((char *) buf, 1, type, 10 * sizeof(int)); check_err(err, "packing/unpacking in indexed_contig_leading_zero_test()"); for (i = 0; i < 10; ++i) { int expected; if (i >= 2 && i < 6) expected = i + 1; else expected = 0; check(buf[i] == expected); } free(buf); /* -------------------------------------------------------------------- */ /* A more rigorous test of the indexed type. Use a hard-to-optimize struct * type to force a more complicated datatype processing path * (MPID_Segment_manipulate in MPICH) */ len[0] = 1; len[1] = 1; adisp[0] = 0; adisp[1] = 8*sizeof(int); types[0] = type; types[1] = MPI_INT; /* struct layout: xx0123xx4x ('x' indicates a hole), one char is an * MPI_INT */ MPI_Type_create_struct(2, len, adisp, types, &struct_type); check_err(err, "creating struct type in indexed_contig_leading_zero_test()"); err = MPI_Type_commit(&struct_type); check_err(err, "committing struct type in indexed_contig_leading_zero_test()"); buf = malloc(10*sizeof(int)); assert(buf != NULL); for (i = 0; i < 10; ++i) { buf[i] = i + 1; } err = pack_and_unpack((char *) buf, 1, struct_type, 10 * sizeof(int)); check_err(err, "packing/unpacking in indexed_contig_test()"); for (i = 0; i < 10; ++i) { int expected; if ((i >= 2 && i < 6) || i == 8) expected = i + 1; else expected = 0; check(buf[i] == expected); } free(buf); MPI_Type_free(&struct_type); MPI_Type_free( &type ); /* -------------------------------------------------------------------- */ /* now do the same as above, but with hindexed */ len[0] = 0; len[1] = 4; len[2] = 0; /* use *_MAX vars to improve our chances of hitting any pointer-casting * bugs in a big way (segfaults, etc.) */ /* FIXME: This should also look at long, or use a different approach */ #if defined(HAVE_LONG_LONG) && defined(LLONG_MAX) if (sizeof(MPI_Aint) == sizeof(long long)) { adisp[0] = (MPI_Aint)LLONG_MAX; adisp[1] = 2*sizeof(int); adisp[2] = (MPI_Aint)LLONG_MAX; } else #endif { adisp[0] = (MPI_Aint)INT_MAX; adisp[1] = 2*sizeof(int); adisp[2] = (MPI_Aint)INT_MAX; } err = MPI_Type_hindexed(3, len, adisp, MPI_INT, &type); check_err(err, "creating hindexed type in indexed_contig_leading_zero_test()"); err = MPI_Type_commit(&type); check_err(err, "committing hindexed type in indexed_contig_leading_zero_test()"); MPI_Type_lb(type, &lb); check(lb == 2 * sizeof(int)); MPI_Type_ub(type, &ub); check(ub == 6 * sizeof(int)); buf = malloc(10*sizeof(int)); assert(buf != NULL); for (i = 0; i < 10; ++i) { buf[i] = i + 1; } err = pack_and_unpack((char *) buf, 1, type, 10 * sizeof(int)); check_err(err, "packing/unpacking in indexed_contig_test()"); for (i = 0; i < 10; ++i) { int expected; if (i >= 2 && i < 6) expected = i + 1; else expected = 0; check(buf[i] == expected); } free(buf); /* -------------------------------------------------------------------- */ /* A more rigorous test of the hindexed type. Use a hard-to-optimize struct * type to force a more complicated datatype processing path * (MPID_Segment_manipulate in MPICH) */ len[0] = 1; len[1] = 1; adisp[0] = 0; adisp[1] = 8*sizeof(int); /* struct layout: xx0123xx4x ('x' indicates a hole), one char is an * MPI_INT */ err = MPI_Type_create_struct(2, len, adisp, types, &struct_type); check_err(err, "committing struct type in indexed_contig_leading_zero_test()"); err = MPI_Type_commit(&struct_type); check_err(err, "committing struct type in indexed_contig_leading_zero_test()"); buf = malloc(10*sizeof(int)); assert(buf != NULL); for (i = 0; i < 10; ++i) { buf[i] = i + 1; } /* fails in old MPICH (3.0rc1 and earlier), despite correct ub/lb * determination */ err = pack_and_unpack((char *) buf, 1, struct_type, 10 * sizeof(int)); check_err(err, "packing/unpacking in indexed_contig_test()"); for (i = 0; i < 10; ++i) { int expected; if ((i >= 2 && i < 6) || i == 8) expected = i + 1; else expected = 0; check(buf[i] == expected); } free(buf); MPI_Type_free(&struct_type); MPI_Type_free(&type); return errs; } /* Test an indexed (and hindexed) type where the block length is the same for * all blocks, but with differing displacements so that it cannot directly be * converted to a vector type. It is also important to add a dummy element at * the beginning in order to cause int/MPI_Aint misalignment for the * displacement of the first non-zero-width component. */ int indexed_same_lengths(void) { int err, errs = 0; int i; MPI_Datatype type = MPI_DATATYPE_NULL; int len[4]; int disp[4]; MPI_Aint adisp[4]; MPI_Aint lb, ub; int *buf = NULL; len[0] = 0; len[1] = 1; len[2] = 1; len[3] = 1; disp[0] = 0; disp[1] = 1; disp[2] = 3; disp[3] = 8; err = MPI_Type_indexed(4, len, disp, MPI_INT, &type); check_err(err, "creating indexed type in indexed_same_lengths()"); err = MPI_Type_commit(&type); check_err(err, "committing indexed type in indexed_same_lengths()"); MPI_Type_lb(type, &lb); check(lb == 1 * sizeof(int)); MPI_Type_ub(type, &ub); check(ub == 9 * sizeof(int)); buf = malloc(10*sizeof(int)); assert(buf != NULL); for (i = 0; i < 10; ++i) { buf[i] = i + 1; } err = pack_and_unpack((char *) buf, 1, type, 10 * sizeof(int)); check_err(err, "packing/unpacking in indexed_same_lengths()"); for (i = 0; i < 10; ++i) { int expected; if (i == 1 || i == 3 || i == 8) expected = i + 1; else expected = 0; check(buf[i] == expected); } free(buf); MPI_Type_free(&type); /* -------------------------------------------------------------------- */ /* now do the same as above, but with hindexed */ len[0] = 0; len[1] = 1; len[2] = 1; len[3] = 1; adisp[0] = 0 * sizeof(int); adisp[1] = 1 * sizeof(int); adisp[2] = 3 * sizeof(int); adisp[3] = 8 * sizeof(int); err = MPI_Type_hindexed(4, len, adisp, MPI_INT, &type); check_err(err, "creating hindexed type in indexed_same_lengths()"); err = MPI_Type_commit(&type); check_err(err, "committing hindexed type in indexed_same_lengths()"); MPI_Type_lb(type, &lb); check(lb == 1 * sizeof(int)); MPI_Type_ub(type, &ub); check(ub == 9 * sizeof(int)); buf = malloc(10*sizeof(int)); assert(buf != NULL); for (i = 0; i < 10; ++i) { buf[i] = i + 1; } err = pack_and_unpack((char *) buf, 1, type, 10 * sizeof(int)); check_err(err, "packing/unpacking in indexed_same_lengths()"); for (i = 0; i < 10; ++i) { int expected; if (i == 1 || i == 3 || i == 8) expected = i + 1; else expected = 0; check(buf[i] == expected); } free(buf); MPI_Type_free(&type); return errs; } /* pack_and_unpack() * * Perform packing and unpacking of a buffer for the purposes of checking * to see if we are processing a type correctly. Zeros the buffer between * these two operations, so the data described by the type should be in * place upon return but all other regions of the buffer should be zero. * * Parameters: * typebuf - pointer to buffer described by datatype and count that * will be packed and then unpacked into * count, datatype - description of typebuf * typebufsz - size of typebuf; used specifically to zero the buffer * between the pack and unpack steps * */ static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz) { char *packbuf; int err, errs = 0, pack_size, type_size, position; err = MPI_Type_size(datatype, &type_size); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_size call; aborting after %d errors\n", errs); } return errs; } type_size *= count; err = MPI_Pack_size(count, datatype, MPI_COMM_SELF, &pack_size); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Pack_size call; aborting after %d errors\n", errs); } return errs; } packbuf = (char *) malloc(pack_size); if (packbuf == NULL) { errs++; if (verbose) { fprintf(stderr, "error in malloc call; aborting after %d errors\n", errs); } return errs; } position = 0; err = MPI_Pack(typebuf, count, datatype, packbuf, type_size, &position, MPI_COMM_SELF); if (position != type_size) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (pack)\n", position, type_size); } memset(typebuf, 0, typebufsz); position = 0; err = MPI_Unpack(packbuf, type_size, &position, typebuf, count, datatype, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Unpack call; aborting after %d errors\n", errs); } return errs; } free(packbuf); if (position != type_size) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (unpack)\n", position, type_size); } return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/get-elements-pairtype.c000644 001750 001750 00000005055 12342443662 025367 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include static int verbose = 0; /* tests */ int double_int_test(void); /* helper functions */ int parse_args(int argc, char **argv); int main(int argc, char **argv) { int err, errs = 0; MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */ parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = double_int_test(); if (err && verbose) fprintf(stderr, "%d errors in double_int test.\n", err); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } /* send a { double, int, double} tuple and receive as a pair of * MPI_DOUBLE_INTs. this should (a) be valid, and (b) result in an * element count of 3. */ int double_int_test(void) { int err, errs = 0, count; struct { double a; int b; double c; } foo; struct { double a; int b; double c; int d; } bar; int blks[3] = { 1, 1, 1 }; MPI_Aint disps[3] = { 0, 0, 0 }; MPI_Datatype types[3] = { MPI_DOUBLE, MPI_INT, MPI_DOUBLE }; MPI_Datatype stype; MPI_Status recvstatus; /* fill in disps[1..2] with appropriate offset */ disps[1] = (MPI_Aint) ((char *) &foo.b - (char *) &foo.a); disps[2] = (MPI_Aint) ((char *) &foo.c - (char *) &foo.a); MPI_Type_create_struct(3, blks, disps, types, &stype); MPI_Type_commit(&stype); err = MPI_Sendrecv(&foo, 1, stype, 0, 0, &bar, 2, MPI_DOUBLE_INT, 0, 0, MPI_COMM_SELF, &recvstatus); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, "MPI_Sendrecv returned error (%d)\n", err); return errs; } err = MPI_Get_elements(&recvstatus, MPI_DOUBLE_INT, &count); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, "MPI_Get_elements returned error (%d)\n", err); } if (count != 3) { errs++; if (verbose) fprintf(stderr, "MPI_Get_elements returned count of %d, should be 3\n", count); } MPI_Type_free( &stype ); return errs; } int parse_args(int argc, char **argv) { if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/transpose-pack.c000644 001750 001750 00000004574 12342443662 024102 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include #include "mpitest.h" #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 0; int parse_args(int argc, char **argv); int main(int argc, char *argv[]) { /* Variable declarations */ int a[100][100], b[100][100]; MPI_Datatype row, xpose; MPI_Aint sizeofint; int /* err, */ errs = 0; int bufsize, position = 0; void *buffer; int i, j; /* Initialize a to some known values. */ for(i = 0; i < 100; i++) { for(j = 0; j < 100; j++) { a[i][j] = i*1000+j; b[i][j] = -1; } } /* Initialize MPI */ MPI_Init(&argc, &argv); parse_args(argc, argv); MPI_Type_extent(MPI_INT, &sizeofint); /* Create datatypes. */ MPI_Type_vector(100, 1, 100, MPI_INT, &row); MPI_Type_hvector(100, 1, sizeofint, row, &xpose); MPI_Type_commit(&xpose); /* Pack it. */ MPI_Pack_size(1, xpose, MPI_COMM_WORLD, &bufsize); buffer = (char *) malloc((unsigned) bufsize); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* err = */ MPI_Pack(a, 1, xpose, buffer, bufsize, &position, MPI_COMM_WORLD); /* Unpack the buffer into b. */ position = 0; /* err = */ MPI_Unpack(buffer, bufsize, &position, b, 100*100, MPI_INT, MPI_COMM_WORLD); for (i = 0; i < 100; i++) { for (j = 0; j < 100; j++) { if(b[i][j] != a[j][i]) { errs++; if (verbose) fprintf(stderr, "b[%d][%d] = %d, should be %d\n", i, j, b[i][j], a[j][i]); } } } MPI_Type_free(&xpose); MPI_Type_free(&row); /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/blockindexed-misc.c000644 001750 001750 00000020264 12342443662 024526 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 0; /* tests */ int blockindexed_contig_test(void); int blockindexed_vector_test(void); /* helper functions */ int parse_args(int argc, char **argv); static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz); int main(int argc, char **argv) { int err, errs = 0; MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */ parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = blockindexed_contig_test(); if (err && verbose) fprintf(stderr, "%d errors in blockindexed test.\n", err); errs += err; err = blockindexed_vector_test(); if (err && verbose) fprintf(stderr, "%d errors in blockindexed vector test.\n", err); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } /* blockindexed_contig_test() * * Tests behavior with a blockindexed that can be converted to a * contig easily. This is specifically for coverage. * * Returns the number of errors encountered. */ int blockindexed_contig_test(void) { int buf[4] = {7, -1, -2, -3}; int err, errs = 0; int i, count = 1; int disp = 0; MPI_Datatype newtype; int size, int_size; MPI_Aint extent; err = MPI_Type_create_indexed_block(count, 1, &disp, MPI_INT, &newtype); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating struct type in blockindexed_contig_test()\n"); } errs++; } MPI_Type_size(MPI_INT, &int_size); err = MPI_Type_size(newtype, &size); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type size in blockindexed_contig_test()\n"); } errs++; } if (size != int_size) { if (verbose) { fprintf(stderr, "error: size != int_size in blockindexed_contig_test()\n"); } errs++; } err = MPI_Type_extent(newtype, &extent); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type extent in blockindexed_contig_test()\n"); } errs++; } if (extent != int_size) { if (verbose) { fprintf(stderr, "error: extent != int_size in blockindexed_contig_test()\n"); } errs++; } MPI_Type_commit(&newtype); err = pack_and_unpack((char *) buf, 1, newtype, 4 * sizeof(int)); if (err != 0) { if (verbose) { fprintf(stderr, "error packing/unpacking in blockindexed_contig_test()\n"); } errs += err; } for (i=0; i < 4; i++) { int goodval; switch(i) { case 0: goodval = 7; break; default: goodval = 0; /* pack_and_unpack() zeros before unpack */ break; } if (buf[i] != goodval) { errs++; if (verbose) fprintf(stderr, "buf[%d] = %d; should be %d\n", i, buf[i], goodval); } } MPI_Type_free( &newtype ); return errs; } /* blockindexed_vector_test() * * Tests behavior with a blockindexed of some vector types; * this shouldn't be easily convertable into anything else. * * Returns the number of errors encountered. */ int blockindexed_vector_test(void) { #define NELT (18) int buf[NELT] = { -1, -1, -1, 1, -2, 2, -3, -3, -3, -4, -4, -4, 3, -5, 4, 5, -6, 6 }; int expected[NELT] = { 0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 3, 0, 4, 5, 0, 6 }; int err, errs = 0; int i, count = 3; int disp[] = {1, 4, 5}; MPI_Datatype vectype, newtype; int size, int_size; /* create a vector type of 2 ints, skipping one in between */ err = MPI_Type_vector(2, 1, 2, MPI_INT, &vectype); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating vector type in blockindexed_contig_test()\n"); } errs++; } err = MPI_Type_create_indexed_block(count, 1, disp, vectype, &newtype); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating blockindexed type in blockindexed_contig_test()\n"); } errs++; } MPI_Type_size(MPI_INT, &int_size); err = MPI_Type_size(newtype, &size); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type size in blockindexed_contig_test()\n"); } errs++; } if (size != 6 * int_size) { if (verbose) { fprintf(stderr, "error: size != 6 * int_size in blockindexed_contig_test()\n"); } errs++; } MPI_Type_commit(&newtype); err = pack_and_unpack((char *) buf, 1, newtype, NELT * sizeof(int)); if (err != 0) { if (verbose) { fprintf(stderr, "error packing/unpacking in blockindexed_vector_test()\n"); } errs += err; } for (i=0; i < NELT; i++) { if (buf[i] != expected[i]) { errs++; if (verbose) fprintf(stderr, "buf[%d] = %d; should be %d\n", i, buf[i], expected[i]); } } MPI_Type_free( &vectype ); MPI_Type_free( &newtype ); return errs; } /* pack_and_unpack() * * Perform packing and unpacking of a buffer for the purposes of checking * to see if we are processing a type correctly. Zeros the buffer between * these two operations, so the data described by the type should be in * place upon return but all other regions of the buffer should be zero. * * Parameters: * typebuf - pointer to buffer described by datatype and count that * will be packed and then unpacked into * count, datatype - description of typebuf * typebufsz - size of typebuf; used specifically to zero the buffer * between the pack and unpack steps * */ static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz) { char *packbuf; int err, errs = 0, pack_size, type_size, position; err = MPI_Type_size(datatype, &type_size); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_size call; aborting after %d errors\n", errs); } return errs; } type_size *= count; err = MPI_Pack_size(count, datatype, MPI_COMM_SELF, &pack_size); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Pack_size call; aborting after %d errors\n", errs); } return errs; } packbuf = (char *) malloc(pack_size); if (packbuf == NULL) { errs++; if (verbose) { fprintf(stderr, "error in malloc call; aborting after %d errors\n", errs); } return errs; } position = 0; err = MPI_Pack(typebuf, count, datatype, packbuf, type_size, &position, MPI_COMM_SELF); if (position != type_size) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (pack)\n", position, type_size); } memset(typebuf, 0, typebufsz); position = 0; err = MPI_Unpack(packbuf, type_size, &position, typebuf, count, datatype, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Unpack call; aborting after %d errors\n", errs); } return errs; } free(packbuf); if (position != type_size) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (unpack)\n", position, type_size); } return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/hindexed_block_contents.c000644 001750 001750 00000004577 12342443662 026032 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2012 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* test based on a bug report from Lisandro Dalcin: * http://lists.mcs.anl.gov/pipermail/mpich-dev/2012-October/000978.html */ #include #include #include /* USE_STRICT_MPI may be defined in mpitestconf.h */ #include "mpitestconf.h" /* assert-like macro that bumps the err count and emits a message */ #define check(x_) \ do { \ if (!(x_)) { \ ++errs; \ if (errs < 10) { \ fprintf(stderr, "check failed: (%s), line %d\n", #x_, __LINE__); \ } \ } \ } while (0) int main(int argc, char **argv) { int errs = 0; int rank; MPI_Datatype t; int count = 4; int blocklength = 2; MPI_Aint displacements[] = {0, 8, 16, 24}; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (!rank) { MPI_Type_create_hindexed_block(count, blocklength, displacements, MPI_INT, &t); MPI_Type_commit(&t); { int ni, na, nd, combiner; int i[1024]; MPI_Aint a[1024]; MPI_Datatype d[1024]; int k; MPI_Type_get_envelope(t, &ni, &na, &nd, &combiner); MPI_Type_get_contents(t, ni, na, nd, i, a, d); check(ni == 2); check(i[0] == 4); check(i[1] == 2); check(na == 4); for (k=0; k < na; k++) check(a[k] == (k * 8)); check(nd == 1); check(d[0] == MPI_INT); } MPI_Type_free(&t); } if (rank == 0) { if (errs) { printf("found %d errors\n", errs); } else { printf(" No errors\n"); } } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/subarray-pack.c000644 001750 001750 00000040133 12342443662 023703 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include static int verbose = 0; /* tests */ int subarray_1d_c_test1(void); int subarray_1d_fortran_test1(void); int subarray_2d_c_test1(void); int subarray_4d_c_test1(void); int subarray_2d_c_test2(void); int subarray_2d_fortran_test1(void); int subarray_4d_fortran_test1(void); /* helper functions */ static int parse_args(int argc, char **argv); static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz); int main(int argc, char **argv) { int err, errs = 0; MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */ parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = subarray_1d_c_test1(); if (err && verbose) fprintf(stderr, "%d errors in 1d subarray c test 1.\n", err); errs += err; err = subarray_1d_fortran_test1(); if (err && verbose) fprintf(stderr, "%d errors in 1d subarray fortran test 1.\n", err); errs += err; err = subarray_2d_c_test1(); if (err && verbose) fprintf(stderr, "%d errors in 2d subarray c test 1.\n", err); errs += err; err = subarray_2d_fortran_test1(); if (err && verbose) fprintf(stderr, "%d errors in 2d subarray fortran test 1.\n", err); errs += err; err = subarray_2d_c_test2(); if (err && verbose) fprintf(stderr, "%d errors in 2d subarray c test 2.\n", err); errs += err; err = subarray_4d_c_test1(); if (err && verbose) fprintf(stderr, "%d errors in 4d subarray c test 1.\n", err); errs += err; err = subarray_4d_fortran_test1(); if (err && verbose) fprintf(stderr, "%d errors in 4d subarray fortran test 1.\n", err); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } /* subarray_1d_c_test1() * * Returns the number of errors encountered. */ int subarray_1d_c_test1(void) { MPI_Datatype subarray; int array[9] = { -1, 1, 2, 3, -2, -3, -4, -5, -6 }; int array_size[] = {9}; int array_subsize[] = {3}; int array_start[] = {1}; int i, err, errs = 0, sizeoftype; /* set up type */ err = MPI_Type_create_subarray(1, /* dims */ array_size, array_subsize, array_start, MPI_ORDER_C, MPI_INT, &subarray); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs); } return errs; } MPI_Type_commit(&subarray); MPI_Type_size(subarray, &sizeoftype); if (sizeoftype != 3 * sizeof(int)) { errs++; if (verbose) fprintf(stderr, "size of type = %d; should be %d\n", sizeoftype, (int) (3 * sizeof(int))); return errs; } err = pack_and_unpack((char *) array, 1, subarray, 9 * sizeof(int)); for (i=0; i < 9; i++) { int goodval; switch (i) { case 1: goodval = 1; break; case 2: goodval = 2; break; case 3: goodval = 3; break; default: goodval = 0; /* pack_and_unpack() zeros before unpacking */ break; } if (array[i] != goodval) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval); } } MPI_Type_free(&subarray); return errs; } /* subarray_1d_fortran_test1() * * Returns the number of errors encountered. */ int subarray_1d_fortran_test1(void) { MPI_Datatype subarray; int array[9] = { -1, 1, 2, 3, -2, -3, -4, -5, -6 }; int array_size[] = {9}; int array_subsize[] = {3}; int array_start[] = {1}; int i, err, errs = 0, sizeoftype; /* set up type */ err = MPI_Type_create_subarray(1, /* dims */ array_size, array_subsize, array_start, MPI_ORDER_FORTRAN, MPI_INT, &subarray); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs); } return errs; } MPI_Type_commit(&subarray); MPI_Type_size(subarray, &sizeoftype); if (sizeoftype != 3 * sizeof(int)) { errs++; if (verbose) fprintf(stderr, "size of type = %d; should be %d\n", sizeoftype, (int) (3 * sizeof(int))); return errs; } err = pack_and_unpack((char *) array, 1, subarray, 9 * sizeof(int)); for (i=0; i < 9; i++) { int goodval; switch (i) { case 1: goodval = 1; break; case 2: goodval = 2; break; case 3: goodval = 3; break; default: goodval = 0; /* pack_and_unpack() zeros before unpacking */ break; } if (array[i] != goodval) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval); } } MPI_Type_free(&subarray); return errs; } /* subarray_2d_test() * * Returns the number of errors encountered. */ int subarray_2d_c_test1(void) { MPI_Datatype subarray; int array[9] = { -1, -2, -3, -4, 1, 2, -5, 3, 4 }; int array_size[2] = {3, 3}; int array_subsize[2] = {2, 2}; int array_start[2] = {1, 1}; int i, err, errs = 0, sizeoftype; /* set up type */ err = MPI_Type_create_subarray(2, /* dims */ array_size, array_subsize, array_start, MPI_ORDER_C, MPI_INT, &subarray); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs); } return errs; } MPI_Type_commit(&subarray); MPI_Type_size(subarray, &sizeoftype); if (sizeoftype != 4*sizeof(int)) { errs++; if (verbose) fprintf(stderr, "size of type = %d; should be %d\n", sizeoftype, (int) (4*sizeof(int))); return errs; } err = pack_and_unpack((char *) array, 1, subarray, 9*sizeof(int)); for (i=0; i < 9; i++) { int goodval; switch (i) { case 4: goodval = 1; break; case 5: goodval = 2; break; case 7: goodval = 3; break; case 8: goodval = 4; break; default: goodval = 0; break; } if (array[i] != goodval) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval); } } MPI_Type_free(&subarray); return errs; } /* subarray_2d_c_test2() * * Returns the number of errors encountered. */ int subarray_2d_c_test2(void) { MPI_Datatype subarray; int array[12] = { -1, -2, -3, -4, 1, 2, -5, -6, -7, -8, -9, -10 }; int array_size[2] = {2, 6}; int array_subsize[2] = {1, 2}; int array_start[2] = {0, 4}; int i, err, errs = 0, sizeoftype; /* set up type */ err = MPI_Type_create_subarray(2, /* dims */ array_size, array_subsize, array_start, MPI_ORDER_C, MPI_INT, &subarray); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs); } return errs; } MPI_Type_commit(&subarray); MPI_Type_size(subarray, &sizeoftype); if (sizeoftype != 2*sizeof(int)) { errs++; if (verbose) fprintf(stderr, "size of type = %d; should be %d\n", sizeoftype, (int) (2*sizeof(int))); return errs; } err = pack_and_unpack((char *) array, 1, subarray, 12*sizeof(int)); for (i=0; i < 12; i++) { int goodval; switch (i) { case 4: goodval = 1; break; case 5: goodval = 2; break; default: goodval = 0; break; } if (array[i] != goodval) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval); } } MPI_Type_free(&subarray); return errs; } /* subarray_4d_c_test1() * * Returns the number of errors encountered. */ int subarray_4d_c_test1(void) { MPI_Datatype subarray; int array[] = { -1111, -1112, -1113, -1114, -1115, -1116, -1121, -1122, -1123, -1124, -1125, -1126, -1131, -1132, -1133, -1134, -1135, -1136, -1211, -1212, -1213, -1214, -1215, -1216, -1221, -1222, -1223, -1224, -1225, -1226, -1231, -1232, -1233, -1234, -1235, -1236, -2111, -2112, -2113, -2114, 1, -2116, -2121, -2122, -2123, -2124, 2, -2126, -2131, -2132, -2133, -2134, 3, -2136, -2211, -2212, -2213, -2214, 4, -2216, -2221, -2222, -2223, -2224, 5, -2226, -2231, -2232, -2233, -2234, 6, -2236 }; int array_size[4] = {2, 2, 3, 6}; int array_subsize[4] = {1, 2, 3, 1}; int array_start[4] = {1, 0, 0, 4}; int i, err, errs = 0, sizeoftype; /* set up type */ err = MPI_Type_create_subarray(4, /* dims */ array_size, array_subsize, array_start, MPI_ORDER_C, MPI_INT, &subarray); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs); } return errs; } MPI_Type_commit(&subarray); MPI_Type_size(subarray, &sizeoftype); if (sizeoftype != 6*sizeof(int)) { errs++; if (verbose) fprintf(stderr, "size of type = %d; should be %d\n", sizeoftype, (int) (6*sizeof(int))); return errs; } err = pack_and_unpack((char *) array, 1, subarray, 72*sizeof(int)); for (i=0; i < 72; i++) { int goodval; switch (i) { case 40: goodval = 1; break; case 46: goodval = 2; break; case 52: goodval = 3; break; case 58: goodval = 4; break; case 64: goodval = 5; break; case 70: goodval = 6; break; default: goodval = 0; break; } if (array[i] != goodval) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval); } } MPI_Type_free(&subarray); return errs; } /* subarray_4d_fortran_test1() * * Returns the number of errors encountered. */ int subarray_4d_fortran_test1(void) { MPI_Datatype subarray; int array[] = { -1111, -1112, -1113, -1114, -1115, -1116, -1121, -1122, -1123, -1124, -1125, -1126, -1131, -1132, -1133, -1134, -1135, -1136, -1211, -1212, -1213, -1214, -1215, -1216, -1221, -1222, -1223, -1224, -1225, -1226, -1231, -1232, -1233, -1234, -1235, -1236, -2111, -2112, -2113, -2114, 1, -2116, -2121, -2122, -2123, -2124, 2, -2126, -2131, -2132, -2133, -2134, 3, -2136, -2211, -2212, -2213, -2214, 4, -2216, -2221, -2222, -2223, -2224, 5, -2226, -2231, -2232, -2233, -2234, 6, -2236 }; int array_size[4] = {6, 3, 2, 2}; int array_subsize[4] = {1, 3, 2, 1}; int array_start[4] = {4, 0, 0, 1}; int i, err, errs = 0, sizeoftype; /* set up type */ err = MPI_Type_create_subarray(4, /* dims */ array_size, array_subsize, array_start, MPI_ORDER_FORTRAN, MPI_INT, &subarray); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs); } return errs; } MPI_Type_commit(&subarray); MPI_Type_size(subarray, &sizeoftype); if (sizeoftype != 6*sizeof(int)) { errs++; if (verbose) fprintf(stderr, "size of type = %d; should be %d\n", sizeoftype, (int) (6*sizeof(int))); return errs; } err = pack_and_unpack((char *) array, 1, subarray, 72*sizeof(int)); for (i=0; i < 72; i++) { int goodval; switch (i) { case 40: goodval = 1; break; case 46: goodval = 2; break; case 52: goodval = 3; break; case 58: goodval = 4; break; case 64: goodval = 5; break; case 70: goodval = 6; break; default: goodval = 0; break; } if (array[i] != goodval) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval); } } MPI_Type_free(&subarray); return errs; } /* subarray_2d_fortran_test1() * * Returns the number of errors encountered. */ int subarray_2d_fortran_test1(void) { MPI_Datatype subarray; int array[12] = { -1, -2, -3, -4, 1, 2, -5, -6, -7, -8, -9, -10 }; int array_size[2] = {6, 2}; int array_subsize[2] = {2, 1}; int array_start[2] = {4, 0}; int i, err, errs = 0, sizeoftype; /* set up type */ err = MPI_Type_create_subarray(2, /* dims */ array_size, array_subsize, array_start, MPI_ORDER_FORTRAN, MPI_INT, &subarray); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_create_subarray call; aborting after %d errors\n", errs); } return errs; } MPI_Type_commit(&subarray); MPI_Type_size(subarray, &sizeoftype); if (sizeoftype != 2*sizeof(int)) { errs++; if (verbose) fprintf(stderr, "size of type = %d; should be %d\n", sizeoftype, (int) (2*sizeof(int))); return errs; } err = pack_and_unpack((char *) array, 1, subarray, 12*sizeof(int)); for (i=0; i < 12; i++) { int goodval; switch (i) { case 4: goodval = 1; break; case 5: goodval = 2; break; default: goodval = 0; break; } if (array[i] != goodval) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval); } } MPI_Type_free(&subarray); return errs; } /******************************************************************/ /* pack_and_unpack() * * Perform packing and unpacking of a buffer for the purposes of checking * to see if we are processing a type correctly. Zeros the buffer between * these two operations, so the data described by the type should be in * place upon return but all other regions of the buffer should be zero. * * Parameters: * typebuf - pointer to buffer described by datatype and count that * will be packed and then unpacked into * count, datatype - description of typebuf * typebufsz - size of typebuf; used specifically to zero the buffer * between the pack and unpack steps * */ static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz) { char *packbuf; int err, errs = 0, pack_size, type_size, position; err = MPI_Type_size(datatype, &type_size); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_size call; aborting after %d errors\n", errs); } return errs; } type_size *= count; err = MPI_Pack_size(count, datatype, MPI_COMM_SELF, &pack_size); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Pack_size call; aborting after %d errors\n", errs); } return errs; } packbuf = (char *) malloc(pack_size); if (packbuf == NULL) { errs++; if (verbose) { fprintf(stderr, "error in malloc call; aborting after %d errors\n", errs); } return errs; } position = 0; err = MPI_Pack(typebuf, count, datatype, packbuf, type_size, &position, MPI_COMM_SELF); if (position != type_size) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (pack)\n", position, type_size); } memset(typebuf, 0, typebufsz); position = 0; err = MPI_Unpack(packbuf, type_size, &position, typebuf, count, datatype, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Unpack call; aborting after %d errors\n", errs); } return errs; } free(packbuf); if (position != type_size) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (unpack)\n", position, type_size); } return errs; } static int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/sizedtypes.c000644 001750 001750 00000004077 12342443662 023351 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test of the sized types, supported in MPI-2"; */ int main( int argc, char *argv[] ) { int errs = 0; int size; MTest_Init( &argc, &argv ); MPI_Type_size( MPI_REAL4, &size ); if (size != 4) { errs ++; printf( "MPI_REAL4 has size %d\n", size ); } MPI_Type_size( MPI_REAL8, &size ); if (size != 8) { errs ++; printf( "MPI_REAL8 has size %d\n", size ); } if (MPI_REAL16 != MPI_DATATYPE_NULL) { MPI_Type_size( MPI_REAL16, &size ); if (size != 16) { errs ++; printf( "MPI_REAL16 has size %d\n", size ); } } MPI_Type_size( MPI_COMPLEX8, &size ); if (size != 8) { errs ++; printf( "MPI_COMPLEX8 has size %d\n", size ); } MPI_Type_size( MPI_COMPLEX16, &size ); if (size != 16) { errs ++; printf( "MPI_COMPLEX16 has size %d\n", size ); } if (MPI_COMPLEX32 != MPI_DATATYPE_NULL) { MPI_Type_size( MPI_COMPLEX32, &size ); if (size != 32) { errs ++; printf( "MPI_COMPLEX32 has size %d\n", size ); } } MPI_Type_size( MPI_INTEGER1, &size ); if (size != 1) { errs ++; printf( "MPI_INTEGER1 has size %d\n", size ); } MPI_Type_size( MPI_INTEGER2, &size ); if (size != 2) { errs ++; printf( "MPI_INTEGER2 has size %d\n", size ); } MPI_Type_size( MPI_INTEGER4, &size ); if (size != 4) { errs ++; printf( "MPI_INTEGER4 has size %d\n", size ); } if (MPI_INTEGER8 != MPI_DATATYPE_NULL) { MPI_Type_size( MPI_INTEGER8, &size ); if (size != 8) { errs ++; printf( "MPI_INTEGER8 has size %d\n", size ); } } #ifdef HAVE_MPI_INTEGER16 if (MPI_INTEGER16 != MPI_DATATYPE_NULL) { MPI_Type_size( MPI_INTEGER16, &size ); if (size != 16) { errs ++; printf( "MPI_INTEGER16 has size %d\n", size ); } } #endif MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/testlist000644 001750 001750 00000002676 12342443666 022607 0ustar00cici000000 000000 #needs PMPI_Type_get_envelope, PMPI_Type_get_contents #contents 1 gaddress 1 #complex games with negative extents... #lbub 1 #needs MPI_Pack, MPI_Unpack #localpack 1 #simple-pack 1 #simple-pack-external 1 #transpose-pack 1 #slice-pack 1 #struct-pack 1 typecommit 1 #needs MPI_Type_get_name #typename 1 #needs MPI_Type_dup #typefree 1 zeroparms 1 #getpartelm 2 #needs MPI_Type_create_resized #tresized 2 #tresized2 2 #needs MPI_Type_match_size #tmatchsize 1 tfree 2 typelb 1 #needs MPI_Pack_size #contigstruct 1 struct-zero-count 1 blockindexed-zero-count 1 #needs MPI_Pack, MPI_unpack, MPI_Pack_size #blockindexed-misc 1 #needs MPI_Pack, MPI_unpack, MPI_Pack_size #indexed-misc 1 #needs MPI_Type_create_subarray #subarray-pack 1 #subarray 2 #needs MPI_Type_create_darray #darray-pack 1 #darray-pack 9 # darray-pack 72 #darray-cyclic 12 #gcc alignment games #pairtype-size-extent 1 simple-commit 1 simple-size-extent 1 #struct-no-real-types 1 #needs MPI_Get_elements #struct-empty-el 1 contig-zero-count 1 #needs MPI_Type_create_resized #simple-resized 1 #needs MPI_Pack #unusual-noncontigs 1 #buggy, and needs MPI_Get_elements #hindexed-zeros 1 #lots-of-types 1 #get-elements-pairtype 1 #unpack 1 struct-ezhov 1 #needs MPI_Pack, MPI_Unpack #zeroblks 1 struct-derived-zeros 1 struct-verydeep 1 #get-elements 1 hindexed_block 1 mpiversion=3.0 hindexed_block_contents 1 mpiversion=3.0 longdouble 1 #large-count 1 mpiversion=3.0 xfail=ticket1767 cxx-types 1 mpiversion=3.0 SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/simple-pack.c000644 001750 001750 00000014751 12342443662 023353 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 0; /* tests */ int builtin_float_test(void); int vector_of_vectors_test(void); int optimizable_vector_of_basics_test(void); /* helper functions */ int parse_args(int argc, char **argv); int main(int argc, char **argv) { int err, errs = 0; MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */ parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = builtin_float_test(); if (err && verbose) fprintf(stderr, "%d errors in builtin float test.\n", err); errs += err; err = vector_of_vectors_test(); if (err && verbose) fprintf(stderr, "%d errors in vector of vectors test.\n", err); errs += err; err = optimizable_vector_of_basics_test(); if (err && verbose) fprintf(stderr, "%d errors in vector of basics test.\n", err); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } /* builtin_float_test() * * Tests functionality of get_envelope() and get_contents() on a MPI_FLOAT. * * Returns the number of errors encountered. */ int builtin_float_test(void) { int nints, nadds, ntypes, combiner; int /* err, */ errs = 0; /* err = */ MPI_Type_get_envelope(MPI_FLOAT, &nints, &nadds, &ntypes, &combiner); if (combiner != MPI_COMBINER_NAMED) errs++; /* Note: it is erroneous to call MPI_Type_get_contents() on a basic. */ return errs; } /* vector_of_vectors_test() * * Builds a vector of a vector of ints. Assuming an int array of size 9 * integers, and treating the array as a 3x3 2D array, this will grab the * corners. * * Returns the number of errors encountered. */ int vector_of_vectors_test(void) { MPI_Datatype inner_vector; MPI_Datatype outer_vector; int array[9] = { 1, -1, 2, -2, -3, -4, 3, -5, 4 }; char *buf; int i, err, errs = 0, sizeoftype, position; /* set up type */ err = MPI_Type_vector(2, 1, 2, MPI_INT, &inner_vector); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, "error in MPI call; aborting after %d errors\n", errs+1); return errs; } err = MPI_Type_vector(2, 1, 2, inner_vector, &outer_vector); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, "error in MPI call; aborting after %d errors\n", errs+1); return errs; } MPI_Type_commit(&outer_vector); MPI_Type_size(outer_vector, &sizeoftype); if (sizeoftype != 4*sizeof(int)) { errs++; if (verbose) fprintf(stderr, "size of type = %d; should be %d\n", (int) sizeoftype, (int) (4*sizeof(int))); return errs; } buf = (char *) malloc(sizeoftype); position = 0; err = MPI_Pack(array, 1, outer_vector, buf, sizeoftype, &position, MPI_COMM_WORLD); if (position != sizeoftype) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (pack)\n", position, sizeoftype); } memset(array, 0, 9*sizeof(int)); position = 0; err = MPI_Unpack(buf, sizeoftype, &position, array, 1, outer_vector, MPI_COMM_WORLD); if (position != sizeoftype) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (unpack)\n", position, sizeoftype); } for (i=0; i < 9; i++) { int goodval; switch (i) { case 0: goodval = 1; break; case 2: goodval = 2; break; case 6: goodval = 3; break; case 8: goodval = 4; break; default: goodval = 0; break; } if (array[i] != goodval) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval); } } MPI_Type_free(&inner_vector); MPI_Type_free(&outer_vector); return errs; } /* optimizable_vector_of_basics_test() * * Builds a vector of ints. Count is 10, blocksize is 2, stride is 2, so this * is equivalent to a contig of 20. * * Returns the number of errors encountered. */ int optimizable_vector_of_basics_test(void) { MPI_Datatype parent_type; int array[20] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }; char *buf; int i, sizeofint, sizeoftype, position; int /* err, */ errs = 0; MPI_Type_size(MPI_INT, &sizeofint); if (sizeofint != sizeof(int)) { errs++; if (verbose) fprintf(stderr, "size of MPI_Int = %d; should be %d\n", sizeofint, (int) sizeof(int)); } /* set up type */ /* err = */ MPI_Type_vector(10, 2, 2, MPI_INT, &parent_type); MPI_Type_commit(&parent_type); MPI_Type_size(parent_type, &sizeoftype); if (sizeoftype != 20 * sizeof(int)) { errs++; if (verbose) fprintf(stderr, "size of vector = %d; should be %d\n", (int) sizeoftype, (int) (20 * sizeof(int))); } buf = (char *) malloc(sizeoftype); position = 0; /* err = */ MPI_Pack(array, 1, parent_type, buf, sizeoftype, &position, MPI_COMM_WORLD); if (position != sizeoftype) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (pack)\n", position, sizeoftype); } memset(array, 0, 20 * sizeof(int)); position = 0; /* err = */ MPI_Unpack(buf, sizeoftype, &position, array, 1, parent_type, MPI_COMM_WORLD); if (position != sizeoftype) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (unpack)\n", position, sizeoftype); } for (i=0; i < 20; i++) { if (array[i] != i) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], i); } } MPI_Type_free(&parent_type); return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/gaddress.c000644 001750 001750 00000001256 12342443662 022736 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" /* static char MTEST_Descrip[] = ""; */ int main( int argc, char *argv[] ) { int errs = 0; int buf[10]; MPI_Aint a1, a2; MTest_Init( &argc, &argv ); MPI_Get_address( &buf[0], &a1 ); MPI_Get_address( &buf[1], &a2 ); if ((int)(a2-a1) != sizeof(int)) { errs++; printf( "Get address of two address did not return values the correct distance apart\n" ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/hindexed_block.c000644 001750 001750 00000021714 12342443662 024105 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif #if !defined(USE_STRICT_MPI) && defined(MPICH) #define TEST_HINDEXED_BLOCK 1 #endif #if defined(TEST_HINDEXED_BLOCK) static int verbose = 0; #endif /* tests */ int hindexed_block_contig_test(void); int hindexed_block_vector_test(void); /* helper functions */ int parse_args(int argc, char **argv); static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz); int main(int argc, char **argv) { #if defined(TEST_HINDEXED_BLOCK) int err; #endif int errs = 0; int rank; MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */ MPI_Comm_rank(MPI_COMM_WORLD, &rank); #if defined(TEST_HINDEXED_BLOCK) parse_args(argc, argv); /* To improve reporting of problems about operations, we * change the error handler to errors return */ MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN); /* perform some tests */ err = hindexed_block_contig_test(); if (err && verbose) fprintf(stderr, "%d errors in hindexed_block test.\n", err); errs += err; err = hindexed_block_vector_test(); if (err && verbose) fprintf(stderr, "%d errors in hindexed_block vector test.\n", err); errs += err; #endif /*defined(TEST_HINDEXED_BLOCK)*/ /* print message and exit */ if (rank == 0) { if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } } MPI_Finalize(); return 0; } #if defined(TEST_HINDEXED_BLOCK) /* hindexed_block_contig_test() * * Tests behavior with a hindexed_block that can be converted to a * contig easily. This is specifically for coverage. * * Returns the number of errors encountered. */ int hindexed_block_contig_test(void) { int buf[4] = { 7, -1, -2, -3 }; int err, errs = 0; int i, count = 1; MPI_Aint disp = 0; MPI_Datatype newtype; int size, int_size; MPI_Aint extent; err = MPI_Type_create_hindexed_block(count, 1, &disp, MPI_INT, &newtype); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating struct type in hindexed_block_contig_test()\n"); } errs++; } MPI_Type_size(MPI_INT, &int_size); err = MPI_Type_size(newtype, &size); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type size in hindexed_block_contig_test()\n"); } errs++; } if (size != int_size) { if (verbose) { fprintf(stderr, "error: size != int_size in hindexed_block_contig_test()\n"); } errs++; } err = MPI_Type_extent(newtype, &extent); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type extent in hindexed_block_contig_test()\n"); } errs++; } if (extent != int_size) { if (verbose) { fprintf(stderr, "error: extent != int_size in hindexed_block_contig_test()\n"); } errs++; } MPI_Type_commit(&newtype); err = pack_and_unpack((char *) buf, 1, newtype, 4 * sizeof(int)); if (err != 0) { if (verbose) { fprintf(stderr, "error packing/unpacking in hindexed_block_contig_test()\n"); } errs += err; } for (i = 0; i < 4; i++) { int goodval; switch (i) { case 0: goodval = 7; break; default: goodval = 0; /* pack_and_unpack() zeros before unpack */ break; } if (buf[i] != goodval) { errs++; if (verbose) fprintf(stderr, "buf[%d] = %d; should be %d\n", i, buf[i], goodval); } } MPI_Type_free(&newtype); return errs; } /* hindexed_block_vector_test() * * Tests behavior with a hindexed_block of some vector types; * this shouldn't be easily convertable into anything else. * * Returns the number of errors encountered. */ int hindexed_block_vector_test(void) { #define NELT (18) int buf[NELT] = { -1, -1, -1, 1, -2, 2, -3, -3, -3, -4, -4, -4, 3, -5, 4, 5, -6, 6 }; int expected[NELT] = { 0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 3, 0, 4, 5, 0, 6 }; int err, errs = 0; int i, count = 3; MPI_Aint disp[] = { 1, 4, 5 }; MPI_Datatype vectype, newtype; int size, int_size; MPI_Aint extent; /* create a vector type of 2 ints, skipping one in between */ err = MPI_Type_vector(2, 1, 2, MPI_INT, &vectype); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating vector type in hindexed_block_contig_test()\n"); } errs++; } MPI_Type_commit(&vectype); MPI_Type_extent(vectype, &extent); for (i = 0; i < count; i++) disp[i] *= extent; err = MPI_Type_create_hindexed_block(count, 1, disp, vectype, &newtype); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating hindexed_block type in hindexed_block_contig_test()\n"); } errs++; } MPI_Type_commit(&newtype); err = MPI_Type_size(newtype, &size); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type size in hindexed_block_contig_test()\n"); } errs++; } MPI_Type_size(MPI_INT, &int_size); if (size != 6 * int_size) { if (verbose) { fprintf(stderr, "error: size != 6 * int_size in hindexed_block_contig_test()\n"); } errs++; } MPI_Type_extent(newtype, &extent); err = pack_and_unpack((char *) buf, 1, newtype, NELT * sizeof(int)); if (err != 0) { if (verbose) { fprintf(stderr, "error packing/unpacking in hindexed_block_vector_test()\n"); } errs += err; } for (i = 0; i < NELT; i++) { if (buf[i] != expected[i]) { errs++; if (verbose) fprintf(stderr, "buf[%d] = %d; should be %d\n", i, buf[i], expected[i]); } } MPI_Type_free(&vectype); MPI_Type_free(&newtype); return errs; } /* pack_and_unpack() * * Perform packing and unpacking of a buffer for the purposes of checking * to see if we are processing a type correctly. Zeros the buffer between * these two operations, so the data described by the type should be in * place upon return but all other regions of the buffer should be zero. * * Parameters: * typebuf - pointer to buffer described by datatype and count that * will be packed and then unpacked into * count, datatype - description of typebuf * typebufsz - size of typebuf; used specifically to zero the buffer * between the pack and unpack steps * */ static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz) { char *packbuf; int err, errs = 0, pack_size, type_size, position; err = MPI_Type_size(datatype, &type_size); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_size call; aborting after %d errors\n", errs); } return errs; } type_size *= count; err = MPI_Pack_size(count, datatype, MPI_COMM_SELF, &pack_size); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Pack_size call; aborting after %d errors\n", errs); } return errs; } packbuf = (char *) malloc(pack_size); if (packbuf == NULL) { errs++; if (verbose) { fprintf(stderr, "error in malloc call; aborting after %d errors\n", errs); } return errs; } position = 0; err = MPI_Pack(typebuf, count, datatype, packbuf, type_size, &position, MPI_COMM_SELF); if (position != type_size) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (pack)\n", position, type_size); } memset(typebuf, 0, typebufsz); position = 0; err = MPI_Unpack(packbuf, type_size, &position, typebuf, count, datatype, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Unpack call; aborting after %d errors\n", errs); } return errs; } free(packbuf); if (position != type_size) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (unpack)\n", position, type_size); } return errs; } int parse_args(int argc, char **argv) { if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } #endif /*defined(TEST_HINDEXED_BLOCK)*/ SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/zeroparms.c000644 001750 001750 00000001475 12342443662 023167 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include int main( int argc, char *argv[] ) { MPI_Datatype newtype; int b[1], d[1]; MPI_Init( &argc, &argv ); /* create a legitimate type to see that we don't * emit spurious errors. */ MPI_Type_hvector( 0, 1, 10, MPI_DOUBLE, &newtype ); MPI_Type_commit( &newtype ); MPI_Type_free( &newtype ); MPI_Type_indexed( 0, b, d, MPI_DOUBLE, &newtype ); MPI_Type_commit( &newtype ); MPI_Sendrecv( b, 1, newtype, 0, 0, d, 0, newtype, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE ); printf( " No Errors\n" ); MPI_Type_free( &newtype ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/longdouble.c000644 001750 001750 00000004001 12342443662 023263 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2012 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include "mpi.h" #include "mpitest.h" /* Some MPI implementations should not support MPI_LONG_DOUBLE because it has * different representations/sizes among several concurrently supported * compilers. For example, a 16-byte GCC implementation and an 8-byte Cray * compiler implementation. * * This test ensures that simplistic build logic/configuration did not result in * a defined, yet incorrectly sized, MPI predefined datatype for long double and * long double _Complex. See tt#1671 for more info. * * Based on a test suggested by Jim Hoekstra @ Iowa State University. */ int main(int argc, char *argv[]) { int rank, size, type_size; int errs = 0; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); if (rank == 0) { #ifdef HAVE_LONG_DOUBLE if (MPI_LONG_DOUBLE != MPI_DATATYPE_NULL) { MPI_Type_size(MPI_LONG_DOUBLE, &type_size); if (type_size != sizeof(long double)) { printf("type_size != sizeof(long double) : (%zd != %zd)\n", (size_t)type_size, sizeof(long double)); ++errs; } } #endif #if defined(HAVE_LONG_DOUBLE__COMPLEX) && defined(USE_LONG_DOUBLE_COMPLEX) if (MPI_C_LONG_DOUBLE_COMPLEX != MPI_DATATYPE_NULL) { MPI_Type_size(MPI_C_LONG_DOUBLE_COMPLEX, &type_size); if (type_size != sizeof(long double _Complex)) { printf("type_size != sizeof(long double _Complex) : (%zd != %zd)\n", (size_t)type_size, sizeof(long double _Complex)); ++errs; } } #endif if (errs) { printf("found %d errors\n", errs); } else { printf(" No errors\n"); } } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/blockindexed-zero-count.c000644 001750 001750 00000005050 12342443662 025674 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 0; /* tests */ int blockindexed_test(void); /* helper functions */ int parse_args(int argc, char **argv); int main(int argc, char **argv) { int err, errs = 0; MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */ parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = blockindexed_test(); if (err && verbose) fprintf(stderr, "%d errors in blockindexed test.\n", err); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } /* blockindexed_test() * * Tests behavior with a zero-count blockindexed. * * Returns the number of errors encountered. */ int blockindexed_test(void) { int err, errs = 0; int count = 0; MPI_Datatype newtype; int size; MPI_Aint extent; err = MPI_Type_create_indexed_block(count, 0, (int *) 0, MPI_INT, &newtype); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating struct type in blockindexed_test()\n"); } errs++; } err = MPI_Type_size(newtype, &size); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type size in blockindexed_test()\n"); } errs++; } if (size != 0) { if (verbose) { fprintf(stderr, "error: size != 0 in blockindexed_test()\n"); } errs++; } err = MPI_Type_extent(newtype, &extent); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type extent in blockindexed_test()\n"); } errs++; } if (extent != 0) { if (verbose) { fprintf(stderr, "error: extent != 0 in blockindexed_test()\n"); } errs++; } MPI_Type_free( &newtype ); return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/darray-cyclic.c000644 001750 001750 00000016034 12342443662 023670 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; -*- */ /* * (C) 2012 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" int AllocateGrid( int nx, int ny, int **srcArray, int **destArray ); int PackUnpack( MPI_Datatype, const int [], int[], int ); int main( int argc, char *argv[] ) { int errs = 0; int wrank, wsize; int gsizes[3], distribs[3], dargs[3], psizes[3]; int px, py, nx, ny, rx, ry, bx, by; int *srcArray=NULL, *destArray=NULL; int i, j, ii, jj, loc; MPI_Datatype darraytype; MTest_Init( 0, 0 ); MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); MPI_Comm_size( MPI_COMM_WORLD, &wsize ); /* Test 1: Simple, 1-D cyclic decomposition */ if (AllocateGrid( 1, 3*wsize, &srcArray, &destArray ) ) { MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } /* Simple cyclic with 1-dim global array */ gsizes[0] = 3*wsize; distribs[0] = MPI_DISTRIBUTE_CYCLIC; dargs[0] = 1; psizes[0] = wsize; MPI_Type_create_darray( wsize, wrank, 1, gsizes, distribs, dargs, psizes, MPI_ORDER_C, MPI_INT, &darraytype ); /* Check the created datatype. Because cyclic, should represent a strided type */ if (PackUnpack( darraytype, srcArray, destArray, 3 )) { fprintf( stderr, "Error in pack/unpack check\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } /* Now, check for correct data */ for (i=0; i<3; i++) { if (destArray[i] != wrank + i * wsize) { fprintf( stderr, "1D: %d: Expected %d but saw %d\n", i, wrank + i * wsize, destArray[i] ); errs++; } } free( destArray ); free( srcArray ); MPI_Type_free( &darraytype ); /* Test 2: Simple, 1-D cyclic decomposition, with block size=2 */ if (AllocateGrid( 1, 4*wsize, &srcArray, &destArray ) ) { MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } /* Simple cyclic with 1-dim global array */ gsizes[0] = 4*wsize; distribs[0] = MPI_DISTRIBUTE_CYCLIC; dargs[0] = 2; psizes[0] = wsize; MPI_Type_create_darray( wsize, wrank, 1, gsizes, distribs, dargs, psizes, MPI_ORDER_C, MPI_INT, &darraytype ); /* Check the created datatype. Because cyclic, should represent a strided type */ if (PackUnpack( darraytype, srcArray, destArray, 4 )) { fprintf( stderr, "Error in pack/unpack check\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } loc = 0; /* for each cyclic element */ for (i=0; i<2; i++) { /* For each element in block */ for (j=0; j<2; j++) { if (destArray[loc] != 2*wrank + i * 2*wsize + j) { fprintf( stderr, "1D(2): %d: Expected %d but saw %d\n", i, 2*wrank + i * 2*wsize+j, destArray[loc] ); errs++; } loc++; } } free( destArray ); free( srcArray ); MPI_Type_free( &darraytype ); /* 2D: Create some 2-D decompositions */ px = wsize/2; py = 2; rx = wrank % px; ry = wrank / px; if (px * py != wsize) { fprintf( stderr, "An even number of processes is required\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } /* Cyclic/Cyclic */ if (AllocateGrid( 5*px, 7*py, &srcArray, &destArray )) { MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } /* Simple cyclic/cyclic. Note in C order, the [1] index varies most rapidly */ gsizes[0] = ny = 7*py; gsizes[1] = nx = 5*px; distribs[0] = MPI_DISTRIBUTE_CYCLIC; distribs[1] = MPI_DISTRIBUTE_CYCLIC; dargs[0] = 1; dargs[1] = 1; psizes[0] = py; psizes[1] = px; MPI_Type_create_darray( wsize, wrank, 2, gsizes, distribs, dargs, psizes, MPI_ORDER_C, MPI_INT, &darraytype ); /* Check the created datatype. Because cyclic, should represent a strided type */ if (PackUnpack( darraytype, srcArray, destArray, 5*7 )) { fprintf( stderr, "Error in pack/unpack check\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } loc = 0; for (j=0; j<7; j++) { for (i=0; i<5; i++) { int expected = rx + ry * nx + i * px + j * nx * py; if (destArray[loc] != expected) { errs++; fprintf( stderr, "2D(cc): [%d,%d] = %d, expected %d\n", i, j, destArray[loc], expected ); } loc++; } } free( srcArray ); free( destArray ); MPI_Type_free( &darraytype ); /* Cyclic(2)/Cyclic(3) */ if (AllocateGrid( 6*px, 4*py, &srcArray, &destArray )) { MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } /* Block cyclic/cyclic. Note in C order, the [1] index varies most rapidly */ gsizes[0] = ny = 4*py; gsizes[1] = nx = 6*px; distribs[0] = MPI_DISTRIBUTE_CYCLIC; distribs[1] = MPI_DISTRIBUTE_CYCLIC; dargs[0] = by = 2; dargs[1] = bx = 3; psizes[0] = py; psizes[1] = px; MPI_Type_create_darray( wsize, wrank, 2, gsizes, distribs, dargs, psizes, MPI_ORDER_C, MPI_INT, &darraytype ); /* Check the created datatype. Because cyclic, should represent a strided type */ if (PackUnpack( darraytype, srcArray, destArray, 4*6 )) { fprintf( stderr, "Error in pack/unpack check\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } loc = 0; for (j=0; j<4/by; j++) { for (jj=0; jj #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 1; int parse_args(int argc, char **argv); MPI_Aint pairtype_displacement(MPI_Datatype type, int *out_size_p); MPI_Aint pairtype_displacement(MPI_Datatype type, int *out_size_p) { MPI_Aint disp; /* Note that a portable test may not use a switch statement for datatypes, as they are not required to be compile-time constants */ if (type == MPI_FLOAT_INT) { struct { float a; int b; } foo; disp = (MPI_Aint) ((char *) &foo.b - (char *) &foo.a); *out_size_p = sizeof(foo); } else if (type == MPI_DOUBLE_INT) { struct { double a; int b; } foo; disp = (MPI_Aint) ((char *) &foo.b - (char *) &foo.a); *out_size_p = sizeof(foo); } else if (type == MPI_LONG_INT) { struct { long a; int b; } foo; disp = (MPI_Aint) ((char *) &foo.b - (char *) &foo.a); *out_size_p = sizeof(foo); } else if (type == MPI_SHORT_INT) { struct { short a; int b; } foo; disp = (MPI_Aint) ((char *) &foo.b - (char *) &foo.a); *out_size_p = sizeof(foo); } else if (type == MPI_LONG_DOUBLE_INT && type != MPI_DATATYPE_NULL) { struct { long double a; int b; } foo; disp = (MPI_Aint) ((char *) &foo.b - (char *) &foo.a); *out_size_p = sizeof(foo); } else { disp = -1; } return disp; } int main(int argc, char *argv[]) { struct { MPI_Datatype atype, ptype; char name[32]; } pairtypes[] = { {MPI_FLOAT, MPI_FLOAT_INT, "MPI_FLOAT_INT"}, {MPI_DOUBLE, MPI_DOUBLE_INT, "MPI_DOUBLE_INT"}, {MPI_LONG, MPI_LONG_INT, "MPI_LONG_INT"}, {MPI_SHORT, MPI_SHORT_INT, "MPI_SHORT_INT"}, {MPI_LONG_DOUBLE, MPI_LONG_DOUBLE_INT, "MPI_LONG_DOUBLE_INT"}, {(MPI_Datatype) -1, (MPI_Datatype) -1, "end"} }; int errs = 0; int i; int blks[2] = {1, 1}; MPI_Aint disps[2] = {0, 0}; MPI_Datatype types[2] = {MPI_INT, MPI_INT}; MPI_Datatype stype; MPI_Init(&argc, &argv); parse_args(argc, argv); for (i=0; pairtypes[i].atype != (MPI_Datatype) -1; i++) { int atype_size, ptype_size, stype_size, handbuilt_extent=0; MPI_Aint ptype_extent, stype_extent, dummy_lb; types[0] = pairtypes[i].atype; /* Check for undefined optional types, such as LONG_DOUBLE_INT (if, for example, long double or long long are not supported) */ if (types[0] == MPI_DATATYPE_NULL) continue; MPI_Type_size(types[0], &atype_size); disps[1] = pairtype_displacement(pairtypes[i].ptype, &handbuilt_extent); MPI_Type_create_struct(2, blks, disps, types, &stype); MPI_Type_size(stype, &stype_size); MPI_Type_size(pairtypes[i].ptype, &ptype_size); if (stype_size != ptype_size) { errs++; if (verbose) fprintf(stderr, "size of %s (%d) does not match size of hand-built MPI struct (%d)\n", pairtypes[i].name, ptype_size, stype_size); } MPI_Type_get_extent(stype, &dummy_lb, &stype_extent); MPI_Type_get_extent(pairtypes[i].ptype, &dummy_lb, &ptype_extent); if (stype_extent != ptype_extent || stype_extent != handbuilt_extent) { errs++; if (verbose) fprintf(stderr, "extent of %s (%d) does not match extent of either hand-built MPI struct (%d) or equivalent C struct (%d)\n", pairtypes[i].name, (int) stype_extent, (int) ptype_extent, handbuilt_extent); } MPI_Type_free( &stype ); } /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } int parse_args(int argc, char **argv) { /* We use a simple test because getopt isn't universally available */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; if (argc > 1 && strcmp(argv[1], "-nov") == 0) verbose = 0; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/slice-pack.c000644 001750 001750 00000005630 12342443662 023155 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include #include "mpitest.h" #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 0; int a[100][100][100], e[9][9][9]; /* helper functions */ static int parse_args(int argc, char **argv); int main(int argc, char *argv[]) { /* Variable declarations */ MPI_Datatype oneslice, twoslice, threeslice; int errs = 0; MPI_Aint sizeofint; int bufsize, position; void *buffer; int i, j, k; /* Initialize a to some known values. */ for (i = 0; i < 100; i++) { for (j = 0; j < 100; j++) { for (k = 0; k < 100; k++) { a[i][j][k] = i*1000000+j*1000+k; } } } /* Initialize MPI */ MPI_Init(&argc, &argv); MPI_Type_extent(MPI_INT, &sizeofint); parse_args(argc, argv); /* Create data types. */ /* NOTE: This differs from the way that it's done on the sheet. */ /* On the sheet, the slice is a[0, 2, 4, ..., 16][2-10][1-9]. */ /* Below, the slice is a[0-8][2-10][1, 3, 5, ..., 17]. */ MPI_Type_vector(9, 1, 2, MPI_INT, &oneslice); MPI_Type_hvector(9, 1, 100*sizeofint, oneslice, &twoslice); MPI_Type_hvector(9, 1, 100*100*sizeofint, twoslice, &threeslice); MPI_Type_commit(&threeslice); /* Pack it into a buffer. */ position = 0; MPI_Pack_size(1, threeslice, MPI_COMM_WORLD, &bufsize); buffer = (void *) malloc((unsigned) bufsize); /* -1 to indices on sheet to compensate for Fortran --> C */ MPI_Pack(&(a[0][2][1]), 1, threeslice, buffer, bufsize, &position, MPI_COMM_WORLD); /* Unpack the buffer into e. */ position = 0; MPI_Unpack(buffer, bufsize, &position, e, 9*9*9, MPI_INT, MPI_COMM_WORLD); /* Display errors, if any. */ for (i = 0; i < 9; i++) { for (j = 0; j < 9; j++) { for (k = 0; k < 9; k++) { /* The truncation in integer division makes this safe. */ if (e[i][j][k] != a[i][j+2][k*2+1]) { errs++; if (verbose) { printf("Error in location %d x %d x %d: %d, should be %d.\n", i, j, k, e[i][j][k], a[i][j+2][k*2+1]); } } } } } /* Release memory. */ free(buffer); if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Type_free(&oneslice); MPI_Type_free(&twoslice); MPI_Type_free(&threeslice); MPI_Finalize(); return 0; } /* parse_args() */ static int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/simple-size-extent.c000644 001750 001750 00000007537 12342443662 024720 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* Tests that Type_get_extent of a couple of basic types succeeds. */ #include "mpi.h" #include #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 0; int parse_args(int argc, char **argv); int main(int argc, char **argv) { int mpi_err, errs = 0, size; MPI_Aint lb, ub, extent; MPI_Datatype type; struct { float a; int b; } foo; MPI_Init(&argc, &argv); parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); type = MPI_INT; mpi_err = MPI_Type_size(type, &size); if (mpi_err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "MPI_Type_size of MPI_INT failed.\n"); } errs++; } if (size != sizeof(int)) { if (verbose) { fprintf(stderr, "MPI_Type_size of MPI_INT incorrect size (%d); should be %d.\n", size, (int) sizeof(int)); } errs++; } mpi_err = MPI_Type_get_extent(type, &lb, &extent); if (mpi_err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "MPI_Type_get_extent of MPI_INT failed.\n"); } errs++; } if (extent != sizeof(int)) { if (verbose) { fprintf(stderr, "MPI_Type_get_extent of MPI_INT returned incorrect extent (%d); should be %d.\n", (int) extent, (int) sizeof(int)); } errs++; } if (lb != 0) { if (verbose) { fprintf(stderr, "MPI_Type_get_extent of MPI_INT returned incorrect lb (%d); should be 0.\n", (int) lb); } errs++; } mpi_err = MPI_Type_ub(type, &ub); if (mpi_err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "MPI_Type_ub of MPI_INT failed.\n"); } errs++; } if (ub != extent - lb) { if (verbose) { fprintf(stderr, "MPI_Type_ub of MPI_INT returned incorrect ub (%d); should be %d.\n", (int) ub, (int) (extent - lb)); } errs++; } type = MPI_FLOAT_INT; mpi_err = MPI_Type_size(type, &size); if (mpi_err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "MPI_Type_size of MPI_FLOAT_INT failed.\n"); } errs++; } if (size != sizeof(float) + sizeof(int)) { if (verbose) { fprintf(stderr, "MPI_Type_size of MPI_FLOAT_INT returned incorrect size (%d); should be %d.\n", size, (int) (sizeof(float) + sizeof(int))); } errs++; } mpi_err = MPI_Type_get_extent(type, &lb, &extent); if (mpi_err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "MPI_Type_get_extent of MPI_FLOAT_INT failed.\n"); } errs++; } if (extent != sizeof(foo)) { if (verbose) { fprintf(stderr, "MPI_Type_get_extent of MPI_FLOAT_INT returned incorrect extent (%d); should be %d.\n", (int) extent, (int) sizeof(foo)); } errs++; } if (lb != 0) { if (verbose) { fprintf(stderr, "MPI_Type_get_extent of MPI_FLOAT_INT returned incorrect lb (%d); should be 0.\n", (int) lb); } errs++; } mpi_err = MPI_Type_ub(type, &ub); if (mpi_err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "MPI_Type_ub of MPI_FLOAT_INT failed.\n"); } errs++; } if (ub != extent - lb) { if (verbose) { fprintf(stderr, "MPI_Type_ub of MPI_FLOAT_INT returned incorrect ub (%d); should be %d.\n", (int) ub, (int) (extent - lb)); } errs++; } /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/struct-ezhov.c000644 001750 001750 00000002700 12342443662 023612 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2008 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include "mpi.h" #include #define COUNT 14 #define SIZE 340 #define EL_COUNT 1131 char s_buf[EL_COUNT*SIZE]; char r_buf[EL_COUNT*SIZE]; int main( int argc, char **argv ) { int rank, size, ret; MPI_Status Status; MPI_Request request; MPI_Datatype struct_type, type1[COUNT]; MPI_Aint disp1[COUNT] = {0, 0, 332, 340}; int block1[COUNT] = {1, 56, 2, 1}; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); type1[0] = MPI_LB; type1[1] = MPI_FLOAT; type1[2] = MPI_FLOAT; type1[3] = MPI_UB; MPI_Type_struct(4, block1, disp1, type1, &struct_type); ret = MPI_Type_commit(&struct_type); if (ret != MPI_SUCCESS) { fprintf(stderr, "Could not make struct type."), fflush(stderr); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } memset(s_buf, 0, EL_COUNT*SIZE); memset(r_buf, 0, EL_COUNT*SIZE); MPI_Isend(s_buf, EL_COUNT, struct_type, 0, 4, MPI_COMM_WORLD, &request); MPI_Recv(r_buf, EL_COUNT, struct_type, 0, 4, MPI_COMM_WORLD, &Status ); MPI_Wait(&request, &Status); MPI_Type_free(&struct_type); MPI_Finalize(); printf(" No Errors\n"); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/tresized2.c000644 001750 001750 00000004054 12342443662 023054 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test of type resized with non-zero LB"; */ int main( int argc, char *argv[] ) { int errs = 0, i; int rank, size, source, dest; int count; int *buf; MPI_Comm comm; MPI_Status status; MPI_Datatype newtype; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); source = 0; dest = size - 1; /* Create an type that is "* INT * " that is, there is a int-sized pad at the beginning of the type, and the extent is still 3 ints. Note, however, that the INT is still at displacement 0, so the effective pattern i*/ MPI_Type_create_resized( MPI_INT, -(int)sizeof(int), 3 * sizeof(int), &newtype ); MPI_Type_commit( &newtype ); for (count = 1; count < 65000; count = count * 2) { buf = (int *)malloc( count * 3 * sizeof(int) ); if (!buf) { MPI_Abort( comm, 1 ); exit(1); } for (i=0; i<3*count; i++) buf[i] = -1; if (rank == source) { for (i=0; i #include #include #include #include "mpi.h" static int verbose = 0; int parse_args(int argc, char **argv); int single_struct_test(void); int array_of_structs_test(void); int struct_of_structs_test(void); struct test_struct_1 { int a,b; char c,d; int e; }; int main(int argc, char *argv[]) { int err, errs = 0; /* Initialize MPI */ MPI_Init(&argc, &argv); parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); err = single_struct_test(); if (verbose && err) fprintf(stderr, "error in single_struct_test\n"); errs += err; err = array_of_structs_test(); if (verbose && err) fprintf(stderr, "error in array_of_structs_test\n"); errs += err; err = struct_of_structs_test(); if (verbose && err) fprintf(stderr, "error in struct_of_structs_test\n"); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } int single_struct_test(void) { int err, errs = 0; int bufsize, position = 0; struct test_struct_1 ts1, ts2; MPI_Datatype mystruct; char *buffer; MPI_Aint disps[3] = {0, 2*sizeof(int), 3*sizeof(int)}; /* guessing... */ int blks[3] = { 2, 2, 1 }; MPI_Datatype types[3] = { MPI_INT, MPI_CHAR, MPI_INT }; ts1.a = 1; ts1.b = 2; ts1.c = 3; ts1.d = 4; ts1.e = 5; err = MPI_Type_struct(3, blks, disps, types, &mystruct); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Type_struct returned error\n"); } } MPI_Type_commit(&mystruct); MPI_Pack_size(1, mystruct, MPI_COMM_WORLD, &bufsize); buffer = (char *) malloc(bufsize); err = MPI_Pack(&ts1, 1, mystruct, buffer, bufsize, &position, MPI_COMM_WORLD); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Pack returned error\n"); } } position = 0; err = MPI_Unpack(buffer, bufsize, &position, &ts2, 1, mystruct, MPI_COMM_WORLD); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Unpack returned error\n"); } } MPI_Type_free(&mystruct); free(buffer); if (ts1.a != ts2.a) { errs++; if (verbose) { fprintf(stderr, "ts2.a = %d; should be %d\n", ts2.a, ts1.a); } } if (ts1.b != ts2.b) { errs++; if (verbose) { fprintf(stderr, "ts2.b = %d; should be %d\n", ts2.b, ts1.b); } } if (ts1.c != ts2.c) { errs++; if (verbose) { fprintf(stderr, "ts2.c = %d; should be %d\n", (int) ts2.c, (int) ts1.c); } } if (ts1.d != ts2.d) { errs++; if (verbose) { fprintf(stderr, "ts2.d = %d; should be %d\n", (int) ts2.d, (int) ts1.d); } } if (ts1.e != ts2.e) { errs++; if (verbose) { fprintf(stderr, "ts2.e = %d; should be %d\n", ts2.e, ts1.e); } } return errs; } int array_of_structs_test(void) { int i, err, errs = 0; int bufsize, position = 0; struct test_struct_1 ts1[10], ts2[10]; MPI_Datatype mystruct; char *buffer; MPI_Aint disps[3] = {0, 2*sizeof(int), 3*sizeof(int)}; /* guessing... */ int blks[3] = { 2, 2, 1 }; MPI_Datatype types[3] = { MPI_INT, MPI_CHAR, MPI_INT }; for (i=0; i < 10; i++) { ts1[i].a = 10*i + 1; ts1[i].b = 10*i + 2; ts1[i].c = 10*i + 3; ts1[i].d = 10*i + 4; ts1[i].e = 10*i + 5; ts2[i].a = -13; ts2[i].b = -13; ts2[i].c = -13; ts2[i].d = -13; ts2[i].e = -13; } err = MPI_Type_struct(3, blks, disps, types, &mystruct); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Type_struct returned error\n"); } } MPI_Type_commit(&mystruct); MPI_Pack_size(10, mystruct, MPI_COMM_WORLD, &bufsize); buffer = (char *) malloc(bufsize); err = MPI_Pack(ts1, 10, mystruct, buffer, bufsize, &position, MPI_COMM_WORLD); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Pack returned error\n"); } } position = 0; err = MPI_Unpack(buffer, bufsize, &position, ts2, 10, mystruct, MPI_COMM_WORLD); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Unpack returned error\n"); } } MPI_Type_free(&mystruct); free(buffer); for (i=0; i < 10; i++) { if (ts1[i].a != ts2[i].a) { errs++; if (verbose) { fprintf(stderr, "ts2[%d].a = %d; should be %d\n", i, ts2[i].a, ts1[i].a); } } if (ts1[i].b != ts2[i].b) { errs++; if (verbose) { fprintf(stderr, "ts2[%d].b = %d; should be %d\n", i, ts2[i].b, ts1[i].b); } } if (ts1[i].c != ts2[i].c) { errs++; if (verbose) { fprintf(stderr, "ts2[%d].c = %d; should be %d\n", i, (int) ts2[i].c, (int) ts1[i].c); } } if (ts1[i].d != ts2[i].d) { errs++; if (verbose) { fprintf(stderr, "ts2[%d].d = %d; should be %d\n", i, (int) ts2[i].d, (int) ts1[i].d); } } if (ts1[i].e != ts2[i].e) { errs++; if (verbose) { fprintf(stderr, "ts2[%d].e = %d; should be %d\n", i, ts2[i].e, ts1[i].e); } } } return errs; } int struct_of_structs_test(void) { int i, j, err, errs = 0, bufsize, position; char buf[50], buf2[50], *packbuf; MPI_Aint disps[3] = {0, 3, 0}; int blks[3] = {2, 1, 0}; MPI_Datatype types[3], chartype, tiletype1, tiletype2, finaltype; /* build a contig of one char to try to keep optimizations * from being applied. */ err = MPI_Type_contiguous(1, MPI_CHAR, &chartype); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "chartype create failed\n"); } return errs; } /* build a type that we can tile a few times */ types[0] = MPI_CHAR; types[1] = chartype; err = MPI_Type_struct(2, blks, disps, types, &tiletype1); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "tiletype1 create failed\n"); } return errs; } /* build the same type again, again to avoid optimizations */ err = MPI_Type_struct(2, blks, disps, types, &tiletype2); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "tiletype2 create failed\n"); } return errs; } /* build a combination of those two tiletypes */ disps[0] = 0; disps[1] = 5; disps[2] = 10; blks[0] = 1; blks[1] = 1; blks[2] = 1; types[0] = tiletype1; types[1] = tiletype2; types[2] = MPI_UB; err = MPI_Type_struct(3, blks, disps, types, &finaltype); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "finaltype create failed\n"); } return errs; } MPI_Type_commit(&finaltype); MPI_Type_free(&chartype); MPI_Type_free(&tiletype1); MPI_Type_free(&tiletype2); MPI_Pack_size(5, finaltype, MPI_COMM_WORLD, &bufsize); packbuf = malloc(bufsize); if (packbuf == NULL) { errs++; if (verbose) { fprintf(stderr, "pack buffer allocation (%d bytes) failed\n", bufsize); } return errs; } for (j=0; j < 10; j++) { for (i=0; i < 5; i++) { if (i == 2 || i == 4) buf[5*j + i] = 0; else buf[5*j + i] = i; } } position = 0; err = MPI_Pack(buf, 5, finaltype, packbuf, bufsize, &position, MPI_COMM_WORLD); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "pack failed\n"); } return errs; } memset(buf2, 0, 50); position = 0; err = MPI_Unpack(packbuf, bufsize, &position, buf2, 5, finaltype, MPI_COMM_WORLD); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "unpack failed\n"); } return errs; } for (j=0; j < 10; j++) { for (i=0; i < 5; i++) { if (buf[5*j + i] != buf2[5*j + i]) { errs++; if (verbose) { fprintf(stderr, "buf2[%d] = %d; should be %d\n", 5*j + i, (int) buf2[5*j+i], (int) buf[5*j+i]); } } } } free(packbuf); MPI_Type_free(&finaltype); return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/cxx-types.c000644 001750 001750 00000004420 12342443662 023102 0ustar00cici000000 000000 /* -*- Mode: c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2012 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* This test checks for the existence of four new C++ named predefined datatypes * that should be accessible from C (and Fortran, not tested here). */ #include #include #include #include /* assert-like macro that bumps the err count and emits a message */ #define check(x_) \ do { \ if (!(x_)) { \ ++errs; \ if (errs < 10) { \ fprintf(stderr, "check failed: (%s), line %d\n", #x_, __LINE__); \ } \ } \ } while (0) int main(int argc, char *argv[]) { int errs = 0; int wrank, wsize; int size; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &wrank); MPI_Comm_size(MPI_COMM_WORLD, &wsize); /* perhaps the MPI library has no CXX support, in which case let's assume * that these constants exist and were set to MPI_DATATYPE_NULL (standard * MPICH behavior). */ #define check_type(type_) \ do { \ size = -1; \ if (type_ != MPI_DATATYPE_NULL) { \ MPI_Type_size(type_, &size); \ check(size > 0); \ } \ } while (0) check_type(MPI_CXX_BOOL); check_type(MPI_CXX_FLOAT_COMPLEX); check_type(MPI_CXX_DOUBLE_COMPLEX); check_type(MPI_CXX_LONG_DOUBLE_COMPLEX); MPI_Reduce((wrank == 0 ? MPI_IN_PLACE : &errs), &errs, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); if (wrank == 0) { if (errs) { printf("found %d errors\n", errs); } else { printf(" No errors\n"); } } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/large-count.c000644 001750 001750 00000025430 12342443662 023362 0ustar00cici000000 000000 /* -*- Mode: c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2012 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* This test checks for large count functionality ("MPI_Count") mandated by * MPI-3, as well as behavior of corresponding pre-MPI-3 interfaces that now * have better defined behavior when an "int" quantity would overflow. */ #include #include #include #include #define equals(a, b) ((long long)(a) == (long long)(b)) /* assert-like macro that bumps the err count and emits a message */ #define check(x_) \ do { \ if (!(x_)) { \ ++errs; \ if (errs < 10) { \ fprintf(stderr, "check failed: (%s), line %d\n", #x_, __LINE__); \ } \ } \ } while (0) /* Abort when using unimplemented functions. Currently, it should not happen, * since sizeof(MPI_Count) == sizeof(int), but it avoids compile errors about * undefined functions. */ #define err_unimpl(func) do { \ fprintf(stderr, "ERROR: %s is not implemented\n", #func); \ abort(); \ } while (0) #define MPI_Type_size_x(a,b) err_unimpl(MPI_Type_size_x) #define MPI_Type_get_extent_x(a,b,c) err_unimpl(MPI_Type_get_extent_x) #define MPI_Type_get_true_extent_x(a,b,c) err_unimpl(MPI_Type_get_true_extent_x) #define MPI_Get_elements_x(a,b,c) err_unimpl(MPI_Get_elements_x) #define MPI_Status_set_elements_x(a,b,c) err_unimpl(MPI_Status_set_elements_x) int main(int argc, char *argv[]) { int errs = 0; int wrank, wsize; int size, elements, count; MPI_Aint lb, extent; MPI_Count size_x, lb_x, extent_x, elements_x; double imx4i_true_extent; MPI_Datatype imax_contig = MPI_DATATYPE_NULL; MPI_Datatype four_ints = MPI_DATATYPE_NULL; MPI_Datatype imx4i = MPI_DATATYPE_NULL; MPI_Datatype imx4i_rsz = MPI_DATATYPE_NULL; MPI_Status status; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &wrank); MPI_Comm_size(MPI_COMM_WORLD, &wsize); check(sizeof(MPI_Count) >= sizeof(int)); check(sizeof(MPI_Count) >= sizeof(MPI_Aint)); check(sizeof(MPI_Count) >= sizeof(MPI_Offset)); /* the following two checks aren't explicitly required by the standard, but * it's hard to imagine a world without them holding true and so most of the * subsequent code probably depends on them to some degree */ check(sizeof(MPI_Aint) >= sizeof(int)); check(sizeof(MPI_Offset) >= sizeof(int)); /* not much point in checking for integer overflow cases if MPI_Count is * only as large as an int */ if (sizeof(MPI_Count) == sizeof(int)) goto epilogue; /* a very large type */ MPI_Type_contiguous(INT_MAX, MPI_CHAR, &imax_contig); MPI_Type_commit(&imax_contig); /* a small-ish contig */ MPI_Type_contiguous(4, MPI_INT, &four_ints); MPI_Type_commit(&four_ints); /* a type with size>INT_MAX */ MPI_Type_vector(INT_MAX/2, 1, 3, four_ints, &imx4i); MPI_Type_commit(&imx4i); /* don't forget, ub for dtype w/ stride doesn't include any holes at the end * of the type, hence the more complicated calculation below */ imx4i_true_extent = 3LL*4LL*sizeof(int)*((INT_MAX/2)-1) + 4LL*sizeof(int); /* sanity check that the MPI_COUNT predefined named datatype exists */ MPI_Send(&imx4i_true_extent, 1, MPI_COUNT, MPI_PROC_NULL, 0, MPI_COMM_SELF); /* the same oversized type but with goofy extents */ MPI_Type_create_resized(imx4i, /*lb=*/INT_MAX, /*extent=*/-1024, &imx4i_rsz); MPI_Type_commit(&imx4i_rsz); /* MPI_Type_size */ MPI_Type_size(imax_contig, &size); check(equals(size, INT_MAX)); MPI_Type_size(four_ints, &size); check(equals(size, 4*sizeof(int))); MPI_Type_size(imx4i, &size); check(equals(size, MPI_UNDEFINED)); /* should overflow an int */ MPI_Type_size(imx4i_rsz, &size); check(equals(size, MPI_UNDEFINED)); /* should overflow an int */ /* MPI_Type_size_x */ MPI_Type_size_x(imax_contig, &size_x); check(equals(size_x, INT_MAX)); MPI_Type_size_x(four_ints, &size_x); check(equals(size_x, 4*sizeof(int))); MPI_Type_size_x(imx4i, &size_x); check(equals(size_x, 4LL*sizeof(int)*(INT_MAX/2))); /* should overflow an int */ MPI_Type_size_x(imx4i_rsz, &size_x); check(equals(size_x, 4LL*sizeof(int)*(INT_MAX/2))); /* should overflow an int */ /* MPI_Type_get_extent */ MPI_Type_get_extent(imax_contig, &lb, &extent); check(equals(lb, 0)); check(equals(extent, INT_MAX)); MPI_Type_get_extent(four_ints, &lb, &extent); check(equals(lb, 0)); check(equals(extent, 4*sizeof(int))); MPI_Type_get_extent(imx4i, &lb, &extent); check(equals(lb, 0)); if (sizeof(MPI_Aint) == sizeof(int)) check(equals(extent, MPI_UNDEFINED)); else check(equals(extent, imx4i_true_extent)); MPI_Type_get_extent(imx4i_rsz, &lb, &extent); check(equals(lb, INT_MAX)); check(equals(extent, -1024)); /* MPI_Type_get_extent_x */ MPI_Type_get_extent_x(imax_contig, &lb_x, &extent_x); check(equals(lb_x, 0)); check(equals(extent_x, INT_MAX)); MPI_Type_get_extent_x(four_ints, &lb_x, &extent_x); check(equals(lb_x, 0)); check(equals(extent_x, 4*sizeof(int))); MPI_Type_get_extent_x(imx4i, &lb_x, &extent_x); check(equals(lb_x, 0)); check(equals(extent_x, imx4i_true_extent)); MPI_Type_get_extent_x(imx4i_rsz, &lb_x, &extent_x); check(equals(lb_x, INT_MAX)); check(equals(extent_x, -1024)); /* MPI_Type_get_true_extent */ MPI_Type_get_true_extent(imax_contig, &lb, &extent); check(equals(lb, 0)); check(equals(extent, INT_MAX)); MPI_Type_get_true_extent(four_ints, &lb, &extent); check(equals(lb, 0)); check(equals(extent, 4*sizeof(int))); MPI_Type_get_true_extent(imx4i, &lb, &extent); check(equals(lb, 0)); if (sizeof(MPI_Aint) == sizeof(int)) check(equals(extent, MPI_UNDEFINED)); else check(equals(extent, imx4i_true_extent)); MPI_Type_get_true_extent(imx4i_rsz, &lb, &extent); check(equals(lb, 0)); if (sizeof(MPI_Aint) == sizeof(int)) check(equals(extent, MPI_UNDEFINED)); else check(equals(extent, imx4i_true_extent)); /* MPI_Type_get_true_extent_x */ MPI_Type_get_true_extent_x(imax_contig, &lb_x, &extent_x); check(equals(lb_x, 0)); check(equals(extent_x, INT_MAX)); MPI_Type_get_true_extent_x(four_ints, &lb_x, &extent_x); check(equals(lb_x, 0)); check(equals(extent_x, 4*sizeof(int))); MPI_Type_get_true_extent_x(imx4i, &lb_x, &extent_x); check(equals(lb_x, 0)); check(equals(extent_x, imx4i_true_extent)); MPI_Type_get_true_extent_x(imx4i_rsz, &lb_x, &extent_x); check(equals(lb_x, 0)); check(equals(extent_x, imx4i_true_extent)); /* MPI_{Status_set_elements,Get_elements}{,_x} */ /* set simple */ MPI_Status_set_elements(&status, MPI_INT, 10); MPI_Get_elements(&status, MPI_INT, &elements); MPI_Get_elements_x(&status, MPI_INT, &elements_x); MPI_Get_count(&status, MPI_INT, &count); check(equals(elements, 10)); check(equals(elements_x, 10)); check(equals(count, 10)); /* set_x simple */ MPI_Status_set_elements_x(&status, MPI_INT, 10); MPI_Get_elements(&status, MPI_INT, &elements); MPI_Get_elements_x(&status, MPI_INT, &elements_x); MPI_Get_count(&status, MPI_INT, &count); check(equals(elements, 10)); check(equals(elements_x, 10)); check(equals(count, 10)); /* Sets elements corresponding to count=1 of the given MPI datatype, using * set_elements and set_elements_x. Checks expected values are returned by * get_elements, get_elements_x, and get_count (including MPI_UNDEFINED * clipping) */ #define check_set_elements(type_, elts_) \ do { \ elements = elements_x = count = 0xfeedface; \ /* can't use legacy "set" for large element counts */ \ if ((elts_) <= INT_MAX) { \ MPI_Status_set_elements(&status, (type_), 1); \ MPI_Get_elements(&status, (type_), &elements); \ MPI_Get_elements_x(&status, (type_), &elements_x); \ MPI_Get_count(&status, (type_), &count); \ check(equals(elements, (elts_))); \ check(equals(elements_x, (elts_))); \ check(equals(count, 1)); \ } \ \ elements = elements_x = count = 0xfeedface; \ MPI_Status_set_elements_x(&status, (type_), 1); \ MPI_Get_elements(&status, (type_), &elements); \ MPI_Get_elements_x(&status, (type_), &elements_x); \ MPI_Get_count(&status, (type_), &count); \ if ((elts_) > INT_MAX) { \ check(equals(elements, MPI_UNDEFINED)); \ } \ else { \ check(equals(elements, (elts_))); \ } \ check(equals(elements_x, (elts_))); \ check(equals(count, 1)); \ } while (0) \ check_set_elements(imax_contig, INT_MAX); check_set_elements(four_ints, 4); check_set_elements(imx4i, 4LL*(INT_MAX/2)); check_set_elements(imx4i_rsz, 4LL*(INT_MAX/2)); epilogue: if (imax_contig != MPI_DATATYPE_NULL) MPI_Type_free(&imax_contig); if (four_ints != MPI_DATATYPE_NULL) MPI_Type_free(&four_ints); if (imx4i != MPI_DATATYPE_NULL) MPI_Type_free(&imx4i); if (imx4i_rsz != MPI_DATATYPE_NULL) MPI_Type_free(&imx4i_rsz); MPI_Reduce((wrank == 0 ? MPI_IN_PLACE : &errs), &errs, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); if (wrank == 0) { if (errs) { printf("found %d errors\n", errs); } else { printf(" No errors\n"); } } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/tfree.c000644 001750 001750 00000005241 12342443662 022245 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test that freed datatypes have reference count semantics"; */ #define VEC_NELM 128 #define VEC_STRIDE 8 int main( int argc, char *argv[] ) { int errs = 0; int rank, size, source, dest, i; MPI_Comm comm; MPI_Status status; MPI_Request req; MPI_Datatype strideType; MPI_Datatype tmpType[1024]; int *buf = 0; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); if (size < 2) { fprintf( stderr, "This test requires at least two processes." ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } source = 0; dest = size - 1; /* The idea here is to create a simple but non-contig datatype, perform an irecv with it, free it, and then create many new datatypes. While not a complete test, if the datatype was freed and the space was reused, this test may detect that error A similar test for sends might work by sending a large enough message to force the use of rendezvous send. */ MPI_Type_vector( VEC_NELM, 1, VEC_STRIDE, MPI_INT, &strideType ); MPI_Type_commit( &strideType ); if (rank == dest) { buf = (int *)malloc( VEC_NELM * VEC_STRIDE * sizeof(int) ); for (i=0; i #include #include /* Tests MPI_Get_elements with a contiguous datatype that triggered a bug in * past versions of MPICH. See ticket #1467 for more info. */ struct test_struct { char a; short b; int c; }; int main(int argc, char **argv) { int rank, count; struct test_struct sendbuf, recvbuf; int blens[3]; MPI_Aint displs[3]; MPI_Datatype types[3]; MPI_Datatype struct_type, contig; MPI_Status status; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); /* We use a contig of a struct in order to satisfy two properties: * (A) a type that contains more than one element type (the struct portion) * (B) a type that has an odd number of ints in its "type contents" (1 in * this case) * This triggers a specific bug in some versions of MPICH. */ blens[0] = 1; displs[0] = offsetof(struct test_struct, a); types[0] = MPI_CHAR; blens[1] = 1; displs[1] = offsetof(struct test_struct, b); types[1] = MPI_SHORT; blens[2] = 1; displs[2] = offsetof(struct test_struct, c); types[2] = MPI_INT; MPI_Type_create_struct(3, blens, displs, types, &struct_type); MPI_Type_contiguous(1, struct_type, &contig); MPI_Type_commit(&struct_type); MPI_Type_commit(&contig); sendbuf.a = 20; sendbuf.b = 30; sendbuf.c = 40; recvbuf.a = -1; recvbuf.b = -1; recvbuf.c = -1; /* send to ourself */ MPI_Sendrecv(&sendbuf, 1, contig, 0, 0, &recvbuf, 1, contig, 0, 0, MPI_COMM_SELF, &status); /* sanity */ assert(sendbuf.a == recvbuf.a); assert(sendbuf.b == recvbuf.b); assert(sendbuf.c == recvbuf.c); /* now check that MPI_Get_elements returns the correct answer and that the * library doesn't explode in the process */ count = 0xdeadbeef; MPI_Get_elements(&status, contig, &count); MPI_Type_free(&struct_type); MPI_Type_free(&contig); if (count != 3) { printf("unexpected value for count, expected 3, got %d\n", count); } else { if (rank == 0) { printf(" No Errors\n"); } } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/darray-pack.c000644 001750 001750 00000020772 12342443662 023344 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include #include "mpitest.h" /* The default behavior of the test routines should be to briefly indicate the cause of any errors - in this test, that means that verbose needs to be set. Verbose should turn on output that is independent of error levels. */ static int verbose = 1; /* tests */ int darray_2d_c_test1(void); int darray_4d_c_test1(void); /* helper functions */ static int parse_args(int argc, char **argv); static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz); int main(int argc, char **argv) { int err, errs = 0; MTest_Init( &argc, &argv ); parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = darray_2d_c_test1(); if (err && verbose) fprintf(stderr, "%d errors in 2d darray c test 1.\n", err); errs += err; err = darray_4d_c_test1(); if (err && verbose) fprintf(stderr, "%d errors in 4d darray c test 1.\n", err); errs += err; /* print message and exit */ /* Allow the use of more than one process - some MPI implementations (including IBM's) check that the number of processes given to Type_create_darray is no larger than MPI_COMM_WORLD */ MTest_Finalize( errs ); MPI_Finalize(); return 0; } /* darray_2d_test1() * * Performs a sequence of tests building darrays with single-element * blocks, running through all the various positions that the element might * come from. * * Returns the number of errors encountered. */ int darray_2d_c_test1(void) { MPI_Datatype darray; int array[9]; /* initialized below */ int array_size[2] = {3, 3}; int array_distrib[2] = {MPI_DISTRIBUTE_BLOCK, MPI_DISTRIBUTE_BLOCK}; int array_dargs[2] = {MPI_DISTRIBUTE_DFLT_DARG, MPI_DISTRIBUTE_DFLT_DARG}; int array_psizes[2] = {3, 3}; int i, rank, err, errs = 0, sizeoftype; /* pretend we are each rank, one at a time */ for (rank=0; rank < 9; rank++) { /* set up buffer */ for (i=0; i < 9; i++) { array[i] = i; } /* set up type */ err = MPI_Type_create_darray(9, /* size */ rank, 2, /* dims */ array_size, array_distrib, array_dargs, array_psizes, MPI_ORDER_C, MPI_INT, &darray); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_create_darray call; aborting after %d errors\n", errs); } MTestPrintError( err ); return errs; } MPI_Type_commit(&darray); MPI_Type_size(darray, &sizeoftype); if (sizeoftype != sizeof(int)) { errs++; if (verbose) fprintf(stderr, "size of type = %d; should be %d\n", sizeoftype, (int) sizeof(int)); return errs; } err = pack_and_unpack((char *) array, 1, darray, 9*sizeof(int)); for (i=0; i < 9; i++) { if ((i == rank) && (array[i] != rank)) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], rank); } else if ((i != rank) && (array[i] != 0)) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], 0); } } MPI_Type_free(&darray); } return errs; } /* darray_4d_c_test1() * * Returns the number of errors encountered. */ int darray_4d_c_test1(void) { MPI_Datatype darray; int array[72]; int array_size[4] = {6, 3, 2, 2}; int array_distrib[4] = { MPI_DISTRIBUTE_BLOCK, MPI_DISTRIBUTE_BLOCK, MPI_DISTRIBUTE_NONE, MPI_DISTRIBUTE_NONE }; int array_dargs[4] = { MPI_DISTRIBUTE_DFLT_DARG, MPI_DISTRIBUTE_DFLT_DARG, MPI_DISTRIBUTE_DFLT_DARG, MPI_DISTRIBUTE_DFLT_DARG }; int array_psizes[4] = {6, 3, 1, 1}; int i, rank, err, errs = 0, sizeoftype; for (rank=0; rank < 18; rank++) { /* set up array */ for (i=0; i < 72; i++) { array[i] = i; } /* set up type */ err = MPI_Type_create_darray(18, /* size */ rank, 4, /* dims */ array_size, array_distrib, array_dargs, array_psizes, MPI_ORDER_C, MPI_INT, &darray); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_create_darray call; aborting after %d errors\n", errs); } MTestPrintError( err ); return errs; } MPI_Type_commit(&darray); /* verify the size of the type */ MPI_Type_size(darray, &sizeoftype); if (sizeoftype != 4*sizeof(int)) { errs++; if (verbose) fprintf(stderr, "size of type = %d; should be %d\n", sizeoftype, (int) (4*sizeof(int))); return errs; } /* pack and unpack the type, zero'ing out all other values */ err = pack_and_unpack((char *) array, 1, darray, 72*sizeof(int)); for (i=0; i < 4*rank; i++) { if (array[i] != 0) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], 0); } } for (i=4*rank; i < 4*rank + 4; i++) { if (array[i] != i) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], i); } } for (i=4*rank+4; i < 72; i++) { if (array[i] != 0) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], 0); } } MPI_Type_free(&darray); } return errs; } /******************************************************************/ /* pack_and_unpack() * * Perform packing and unpacking of a buffer for the purposes of checking * to see if we are processing a type correctly. Zeros the buffer between * these two operations, so the data described by the type should be in * place upon return but all other regions of the buffer should be zero. * * Parameters: * typebuf - pointer to buffer described by datatype and count that * will be packed and then unpacked into * count, datatype - description of typebuf * typebufsz - size of typebuf; used specifically to zero the buffer * between the pack and unpack steps * */ static int pack_and_unpack(char *typebuf, int count, MPI_Datatype datatype, int typebufsz) { char *packbuf; int err, errs = 0, pack_size, type_size, position; err = MPI_Type_size(datatype, &type_size); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Type_size call; aborting after %d errors\n", errs); } MTestPrintError( err ); return errs; } type_size *= count; err = MPI_Pack_size(count, datatype, MPI_COMM_SELF, &pack_size); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Pack_size call; aborting after %d errors\n", errs); } MTestPrintError( err ); return errs; } packbuf = (char *) malloc(pack_size); if (packbuf == NULL) { errs++; if (verbose) { fprintf(stderr, "error in malloc call; aborting after %d errors\n", errs); } return errs; } /* FIXME: the pack size returned need not be the type_size - this will only be true if the pack routine simply moves the bytes but does no other transformations of the data */ position = 0; err = MPI_Pack(typebuf, count, datatype, packbuf, type_size, &position, MPI_COMM_SELF); if (position != type_size) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (pack)\n", position, type_size); } memset(typebuf, 0, typebufsz); position = 0; err = MPI_Unpack(packbuf, type_size, &position, typebuf, count, datatype, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "error in MPI_Unpack call; aborting after %d errors\n", errs); } MTestPrintError( err ); return errs; } free(packbuf); if (position != type_size) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (unpack)\n", position, type_size); } return errs; } static int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/contig-zero-count.c000644 001750 001750 00000004703 12342443662 024530 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 0; /* tests */ int contig_test(void); /* helper functions */ int parse_args(int argc, char **argv); int main(int argc, char **argv) { int err, errs = 0; MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */ parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = contig_test(); if (err && verbose) fprintf(stderr, "%d errors in contig test.\n", err); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } /* contig_test() * * Tests behavior with a zero-count contig. * * Returns the number of errors encountered. */ int contig_test(void) { int err, errs = 0; int count = 0; MPI_Datatype newtype; int size; MPI_Aint extent; err = MPI_Type_contiguous(count, MPI_INT, &newtype); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating type in contig_test()\n"); } errs++; } err = MPI_Type_size(newtype, &size); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type size in contig_test()\n"); } errs++; } if (size != 0) { if (verbose) { fprintf(stderr, "error: size != 0 in contig_test()\n"); } errs++; } err = MPI_Type_extent(newtype, &extent); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type extent in contig_test()\n"); } errs++; } if (extent != 0) { if (verbose) { fprintf(stderr, "error: extent != 0 in contig_test()\n"); } errs++; } MPI_Type_free( &newtype ); return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/lots-of-types.c000644 001750 001750 00000010477 12342443662 023674 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include #include #include "mpi.h" #include "mpitest.h" /* The default behavior of the test routines should be to briefly indicate the cause of any errors - in this test, that means that verbose needs to be set. Verbose should turn on output that is independent of error levels. */ static int verbose = 1; int parse_args(int argc, char **argv); int lots_of_types_test(void); struct test_struct_1 { int a,b,c,d; }; int main(int argc, char *argv[]) { int err, errs = 0; /* Initialize MPI */ MTest_Init(&argc, &argv); parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); err = lots_of_types_test(); if (verbose && err) fprintf(stderr, "error in lots_of_types_test\n"); errs += err; /* print message and exit */ MTest_Finalize( errs ); MPI_Finalize(); return 0; } /* this test allocates 1024 indexed datatypes with 1024 distinct blocks * each. it's possible that a low memory machine will run out of memory * running this test; it appears to take ~25MB of memory at this time. * -- Rob Ross, 11/2/2005 */ #define NUM_DTYPES 1024 #define NUM_BLOCKS 1024 int lots_of_types_test(void) { int err, errs = 0; int i; MPI_Datatype mytypes[NUM_DTYPES]; int sendbuf[4] = { 1, 2, 3, 4 }; int count, elements; MPI_Request request; MPI_Status status; /* note: first element of struct has zero blklen and should be dropped */ int disps[NUM_BLOCKS]; int blks[NUM_BLOCKS]; for (i=0; i < NUM_DTYPES; i++) mytypes[i] = MPI_DATATYPE_NULL; for (i=0; i < NUM_DTYPES; i++) { int j; disps[0] = 0; blks[0] = 4; for (j=1; j < NUM_BLOCKS; j++) { disps[j] = 4 * j; blks[j] = (j % 3) + 1; } err = MPI_Type_indexed(NUM_BLOCKS, blks, disps, MPI_INT, &mytypes[i]); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Type_indexed returned error on type %d\n", i); } mytypes[i] = MPI_DATATYPE_NULL; goto fn_exit; } MPI_Type_commit(&mytypes[i]); } for (i=0; i < NUM_DTYPES; i++) { int j; int recvbuf[4] = { -1, -1, -1, -1 }; /* we will only receive 4 ints, so short buffer is ok */ err = MPI_Irecv(recvbuf, 1, mytypes[i], 0, 0, MPI_COMM_SELF, &request); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Irecv returned error\n"); } } err = MPI_Send(sendbuf, 4, MPI_INT, 0, 0, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Send returned error\n"); } } err = MPI_Wait(&request, &status); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Wait returned error\n"); } } /* verify data */ for (j=0; j < 4; j++) { if (recvbuf[j] != sendbuf[j]) { errs++; if (verbose) { fprintf(stderr, "recvbuf[%d] = %d; should be %d\n", j, recvbuf[j], sendbuf[j]); } } } /* verify count and elements */ err = MPI_Get_count(&status, mytypes[i], &count); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Get_count returned error\n"); } } if (count != MPI_UNDEFINED) { errs++; if (verbose) { fprintf(stderr, "count = %d; should be MPI_UNDEFINED (%d)\n", count, MPI_UNDEFINED); } } err = MPI_Get_elements(&status, mytypes[i], &elements); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Get_elements returned error\n"); } } if (elements != 4) { errs++; if (verbose) { fprintf(stderr, "elements = %d; should be 4\n", elements); } } } fn_exit: for (i=0; i < NUM_DTYPES; i++) { if (mytypes[i] != MPI_DATATYPE_NULL) MPI_Type_free(&mytypes[i]); } return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/typecommit.c000644 001750 001750 00000002653 12342443662 023336 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2006 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include "mpitest.h" void foo(void *sendbuf, MPI_Datatype sendtype, void *recvbuf, MPI_Datatype recvtype); void foo(void *sendbuf, MPI_Datatype sendtype, void *recvbuf, MPI_Datatype recvtype) { int blocks[2]; MPI_Aint struct_displs[2]; MPI_Datatype types[2], tmp_type; blocks[0] = 256; MPI_Get_address( sendbuf, &struct_displs[0] ); types[0] = sendtype; blocks[1] = 256; MPI_Get_address( recvbuf, &struct_displs[1] ); types[1] = MPI_BYTE; MPI_Type_create_struct(2, blocks, struct_displs, types, &tmp_type); MPI_Type_commit(&tmp_type); MPI_Type_free(&tmp_type); } int main(int argc, char **argv) { int errs = 0; MTest_Init(&argc, &argv); foo((void*) 0x1, MPI_FLOAT_INT, (void*) 0x2, MPI_BYTE); foo((void*) 0x1, MPI_DOUBLE_INT, (void*) 0x2, MPI_BYTE); foo((void*) 0x1, MPI_LONG_INT, (void*) 0x2, MPI_BYTE); foo((void*) 0x1, MPI_SHORT_INT, (void*) 0x2, MPI_BYTE); foo((void*) 0x1, MPI_2INT, (void*) 0x2, MPI_BYTE); #ifdef HAVE_LONG_DOUBLE /* Optional type may be NULL */ if (MPI_LONG_DOUBLE_INT != MPI_DATATYPE_NULL) { foo((void*) 0x1, MPI_LONG_DOUBLE_INT, (void*) 0x2, MPI_BYTE); } #endif MTest_Finalize(errs); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/zeroblks.c000644 001750 001750 00000003156 12342443662 022776 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include "mpi.h" #include "mpitest.h" int main( int argc, char *argv[] ) { int errs = 0; int position, pack_size, i; int dis[2], blklens[2]; MPI_Datatype type; int send_buffer[60]; int recv_buffer[60]; int pack_buffer[1000]; MTest_Init( &argc, &argv ); /* Initialize data in the buffers */ for (i=0; i<60; i++) { send_buffer[i] = i; recv_buffer[i] = -1; pack_buffer[i] = -2; } /* Create an indexed type with an empty first block */ dis[0] = 0; dis[1] = 20; blklens[0] = 0; blklens[1] = 40; MPI_Type_indexed(2, blklens, dis, MPI_INT, &type); MPI_Type_commit(&type); position = 0; MPI_Pack( send_buffer, 1, type, pack_buffer, sizeof(pack_buffer), &position, MPI_COMM_WORLD ); pack_size = position; position = 0; MPI_Unpack( pack_buffer, pack_size, &position, recv_buffer, 1, type, MPI_COMM_WORLD ); /* Check that the last 40 entries of the recv_buffer have the corresponding elements from the send buffer */ for (i=0; i<20; i++) { if (recv_buffer[i] != -1) { errs++; fprintf( stderr, "recv_buffer[%d] = %d, should = -1\n", i, recv_buffer[i] ); } } for (i=20; i<60; i++) { if (recv_buffer[i] != i) { errs++; fprintf( stderr, "recv_buffer[%d] = %d, should = %d\n", i, recv_buffer[i], i ); } } MPI_Type_free( &type ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/struct-empty-el.c000644 001750 001750 00000010473 12342443662 024221 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include #include #include "mpi.h" static int verbose = 0; int parse_args(int argc, char **argv); int single_struct_test(void); struct test_struct_1 { int a,b,c,d; }; int main(int argc, char *argv[]) { int err, errs = 0; /* Initialize MPI */ MPI_Init(&argc, &argv); parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); err = single_struct_test(); if (verbose && err) fprintf(stderr, "error in single_struct_test\n"); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } int single_struct_test(void) { int err, errs = 0; int count, elements; int sendbuf[6] = { 1, 2, 3, 4, 5, 6 }; struct test_struct_1 ts1[2]; MPI_Datatype mystruct; MPI_Request request; MPI_Status status; /* note: first element of struct has zero blklen and should be dropped */ MPI_Aint disps[3] = { 2*sizeof(float), 0, 2*sizeof(int) }; int blks[3] = { 0, 1, 2 }; MPI_Datatype types[3] = { MPI_FLOAT, MPI_INT, MPI_INT }; ts1[0].a = -1; ts1[0].b = -1; ts1[0].c = -1; ts1[0].d = -1; ts1[1].a = -1; ts1[1].b = -1; ts1[1].c = -1; ts1[1].d = -1; err = MPI_Type_struct(3, blks, disps, types, &mystruct); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Type_struct returned error\n"); } } MPI_Type_commit(&mystruct); err = MPI_Irecv(ts1, 2, mystruct, 0, 0, MPI_COMM_SELF, &request); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Irecv returned error\n"); } } err = MPI_Send(sendbuf, 6, MPI_INT, 0, 0, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Send returned error\n"); } } err = MPI_Wait(&request, &status); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Wait returned error\n"); } } /* verify data */ if (ts1[0].a != 1) { errs++; if (verbose) { fprintf(stderr, "ts1[0].a = %d; should be %d\n", ts1[0].a, 1); } } if (ts1[0].b != -1) { errs++; if (verbose) { fprintf(stderr, "ts1[0].b = %d; should be %d\n", ts1[0].b, -1); } } if (ts1[0].c != 2) { errs++; if (verbose) { fprintf(stderr, "ts1[0].c = %d; should be %d\n", ts1[0].c, 2); } } if (ts1[0].d != 3) { errs++; if (verbose) { fprintf(stderr, "ts1[0].d = %d; should be %d\n", ts1[0].d, 3); } } if (ts1[1].a != 4) { errs++; if (verbose) { fprintf(stderr, "ts1[1].a = %d; should be %d\n", ts1[1].a, 4); } } if (ts1[1].b != -1) { errs++; if (verbose) { fprintf(stderr, "ts1[1].b = %d; should be %d\n", ts1[1].b, -1); } } if (ts1[1].c != 5) { errs++; if (verbose) { fprintf(stderr, "ts1[1].c = %d; should be %d\n", ts1[1].c, 5); } } if (ts1[1].d != 6) { errs++; if (verbose) { fprintf(stderr, "ts1[1].d = %d; should be %d\n", ts1[1].d, 6); } } /* verify count and elements */ err = MPI_Get_count(&status, mystruct, &count); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Get_count returned error\n"); } } if (count != 2) { errs++; if (verbose) { fprintf(stderr, "count = %d; should be 2\n", count); } } err = MPI_Get_elements(&status, mystruct, &elements); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Get_elements returned error\n"); } } if (elements != 6) { errs++; if (verbose) { fprintf(stderr, "elements = %d; should be 6\n", elements); } } MPI_Type_free(&mystruct); return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/localpack.c000644 001750 001750 00000004013 12342443662 023065 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* based on the pack.c test in the mpich suite. */ #include "mpi.h" #include #include #include #include "mpitest.h" #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 0; #define BUF_SIZE 16384 int parse_args(int argc, char **argv); int main(int argc, char *argv[]) { int errs = 0; char buffer[BUF_SIZE]; int n, size; double a,b; int pos; /* Initialize MPI */ MPI_Init(&argc, &argv); parse_args(argc, argv); pos = 0; n = 10; a = 1.1; b = 2.2; MPI_Pack(&n, 1, MPI_INT, buffer, BUF_SIZE, &pos, MPI_COMM_WORLD); MPI_Pack(&a, 1, MPI_DOUBLE, buffer, BUF_SIZE, &pos, MPI_COMM_WORLD); MPI_Pack(&b, 1, MPI_DOUBLE, buffer, BUF_SIZE, &pos, MPI_COMM_WORLD); size = pos; pos = 0; n = 0; a = 0; b = 0; MPI_Unpack(buffer, size, &pos, &n, 1, MPI_INT, MPI_COMM_WORLD); MPI_Unpack(buffer, size, &pos, &a, 1, MPI_DOUBLE, MPI_COMM_WORLD); MPI_Unpack(buffer, size, &pos, &b, 1, MPI_DOUBLE, MPI_COMM_WORLD); /* Check results */ if (n != 10) { errs++; if (verbose) fprintf(stderr, "Wrong value for n; got %d expected %d\n", n, 10 ); } if (a != 1.1) { errs++; if (verbose) fprintf(stderr, "Wrong value for a; got %f expected %f\n", a, 1.1 ); } if (b != 2.2) { errs++; if (verbose) fprintf(stderr, "Wrong value for b; got %f expected %f\n", b, 2.2 ); } /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/slice-pack-external.c000644 001750 001750 00000005726 12342443662 025003 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include #include #include "mpi.h" static int verbose = 0; int a[100][100][100], e[9][9][9]; /* helper functions */ static int parse_args(int argc, char **argv); int main(int argc, char *argv[]) { /* Variable declarations */ MPI_Datatype oneslice, twoslice, threeslice; int errs = 0; MPI_Aint sizeofint, bufsize, position; void *buffer; int i, j, k; /* Initialize a to some known values. */ for (i = 0; i < 100; i++) { for (j = 0; j < 100; j++) { for (k = 0; k < 100; k++) { a[i][j][k] = i*1000000+j*1000+k; } } } /* Initialize MPI */ MPI_Init(&argc, &argv); MPI_Type_extent(MPI_INT, &sizeofint); parse_args(argc, argv); /* Create data types. */ /* NOTE: This differs from the way that it's done on the sheet. */ /* On the sheet, the slice is a[0, 2, 4, ..., 16][2-10][1-9]. */ /* Below, the slice is a[0-8][2-10][1, 3, 5, ..., 17]. */ MPI_Type_vector(9, 1, 2, MPI_INT, &oneslice); MPI_Type_hvector(9, 1, 100*sizeofint, oneslice, &twoslice); MPI_Type_hvector(9, 1, 100*100*sizeofint, twoslice, &threeslice); MPI_Type_commit(&threeslice); /* Pack it into a buffer. */ position = 0; /* MPI_Pack_size(1, threeslice, MPI_COMM_WORLD, &bufsize); */ MPI_Pack_external_size((char*)"external32", 1, threeslice, &bufsize); if (bufsize != 2916) { fprintf(stderr," Error on pack size! Got %d; expecting %d\n", (int) bufsize, 2916); } buffer = (void *) malloc((unsigned) bufsize); /* -1 to indices on sheet to compensate for Fortran --> C */ MPI_Pack_external((char*)"external32", &(a[0][2][1]), 1, threeslice, buffer, bufsize, &position); /* Unpack the buffer into e. */ position = 0; MPI_Unpack_external((char*)"external32", buffer, bufsize, &position, e, 9*9*9, MPI_INT); /* Display errors, if any. */ for (i = 0; i < 9; i++) { for (j = 0; j < 9; j++) { for (k = 0; k < 9; k++) { /* The truncation in integer division makes this safe. */ if (e[i][j][k] != a[i][j+2][k*2+1]) { errs++; if (verbose) { printf("Error in location %d x %d x %d: %d, should be %d.\n", i, j, k, e[i][j][k], a[i][j+2][k*2+1]); } } } } } /* Release memory. */ free(buffer); if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Type_free(&oneslice); MPI_Type_free(&twoslice); MPI_Type_free(&threeslice); MPI_Finalize(); return 0; } /* parse_args() */ static int parse_args(int argc, char **argv) { int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/contents.c000644 001750 001750 00000056561 12342443662 023010 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitestconf.h" #ifdef HAVE_UNISTD_H #include #endif #include #include static int verbose = 0; /* tests */ int builtin_float_test(void); int vector_of_vectors_test(void); int optimizable_vector_of_basics_test(void); int indexed_of_basics_test(void); int indexed_of_vectors_test(void); int struct_of_basics_test(void); /* helper functions */ char *combiner_to_string(int combiner); int parse_args(int argc, char **argv); int main(int argc, char **argv) { int err, errs = 0; MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */ parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = builtin_float_test(); errs += err; if (err) { fprintf(stderr, "Found %d errors in builtin float test.\n", err); } err = vector_of_vectors_test(); errs += err; if (err) { fprintf(stderr, "Found %d errors in vector of vectors test.\n", err); } err = optimizable_vector_of_basics_test(); errs += err; if (err) { fprintf(stderr, "Found %d errors in vector of basics test.\n", err); } err = indexed_of_basics_test(); errs += err; if (err) { fprintf(stderr, "Found %d errors in indexed of basics test.\n", err); } err = indexed_of_vectors_test(); errs += err; if (err) { fprintf(stderr, "Found %d errors in indexed of vectors test.\n", err); } #ifdef HAVE_MPI_TYPE_CREATE_STRUCT err = struct_of_basics_test(); errs += err; #endif /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } /* builtin_float_test() * * Tests functionality of get_envelope() and get_contents() on a MPI_FLOAT. * * Returns the number of errors encountered. */ int builtin_float_test(void) { int nints, nadds, ntypes, combiner; int /* err, */ errs = 0; /* err = */ MPI_Type_get_envelope(MPI_FLOAT, &nints, &nadds, &ntypes, &combiner); if (combiner != MPI_COMBINER_NAMED) errs++; if (verbose && combiner != MPI_COMBINER_NAMED) fprintf(stderr, "combiner = %s; should be named\n", combiner_to_string(combiner)); /* Note: it is erroneous to call MPI_Type_get_contents() on a basic. */ return errs; } /* vector_of_vectors_test() * * Builds a vector of a vector of ints. Assuming an int array of size 9 * integers, and treating the array as a 3x3 2D array, this will grab the * corners. * * Returns the number of errors encountered. */ int vector_of_vectors_test(void) { MPI_Datatype inner_vector, inner_vector_copy; MPI_Datatype outer_vector; int nints, nadds, ntypes, combiner, *ints; MPI_Aint *adds = NULL; MPI_Datatype *types; int err, errs = 0; /* set up type */ err = MPI_Type_vector(2, 1, 2, MPI_INT, &inner_vector); if (err != MPI_SUCCESS) { if (verbose) fprintf(stderr, "error in MPI call; aborting after %d errors\n", errs+1); return errs+1; } err = MPI_Type_vector(2, 1, 2, inner_vector, &outer_vector); if (err != MPI_SUCCESS) { if (verbose) fprintf(stderr, "error in MPI call; aborting after %d errors\n", errs+1); return errs+1; } /* decode outer vector (get envelope, then contents) */ err = MPI_Type_get_envelope(outer_vector, &nints, &nadds, &ntypes, &combiner); if (err != MPI_SUCCESS) { if (verbose) fprintf(stderr, "error in MPI call; aborting after %d errors\n", errs+1); return errs+1; } if (nints != 3) errs++; if (nadds != 0) errs++; if (ntypes != 1) errs++; if (combiner != MPI_COMBINER_VECTOR) errs++; if (verbose) { if (nints != 3) fprintf(stderr, "outer vector nints = %d; should be 3\n", nints); if (nadds != 0) fprintf(stderr, "outer vector nadds = %d; should be 0\n", nadds); if (ntypes != 1) fprintf(stderr, "outer vector ntypes = %d; should be 1\n", ntypes); if (combiner != MPI_COMBINER_VECTOR) fprintf(stderr, "outer vector combiner = %s; should be vector\n", combiner_to_string(combiner)); } if (errs) { if (verbose) fprintf(stderr, "aborting after %d errors\n", errs); return errs; } ints = malloc(nints * sizeof(*ints)); if (nadds) adds = malloc(nadds * sizeof(*adds)); types = malloc(ntypes * sizeof(*types)); /* get contents of outer vector */ err = MPI_Type_get_contents(outer_vector, nints, nadds, ntypes, ints, adds, types); if (ints[0] != 2) errs++; if (ints[1] != 1) errs++; if (ints[2] != 2) errs++; if (verbose) { if (ints[0] != 2) fprintf(stderr, "outer vector count = %d; should be 2\n", ints[0]); if (ints[1] != 1) fprintf(stderr, "outer vector blocklength = %d; should be 1\n", ints[1]); if (ints[2] != 2) fprintf(stderr, "outer vector stride = %d; should be 2\n", ints[2]); } if (errs) { if (verbose) fprintf(stderr, "aborting after %d errors\n", errs); return errs; } inner_vector_copy = types[0]; free(ints); if (nadds) free(adds); free(types); /* decode inner vector */ err = MPI_Type_get_envelope(inner_vector_copy, &nints, &nadds, &ntypes, &combiner); if (err != MPI_SUCCESS) { if (verbose) fprintf(stderr, "error in MPI call; aborting after %d errors\n", errs+1); return errs+1; } if (nints != 3) errs++; if (nadds != 0) errs++; if (ntypes != 1) errs++; if (combiner != MPI_COMBINER_VECTOR) errs++; if (verbose) { if (nints != 3) fprintf(stderr, "inner vector nints = %d; should be 3\n", nints); if (nadds != 0) fprintf(stderr, "inner vector nadds = %d; should be 0\n", nadds); if (ntypes != 1) fprintf(stderr, "inner vector ntypes = %d; should be 1\n", ntypes); if (combiner != MPI_COMBINER_VECTOR) fprintf(stderr, "inner vector combiner = %s; should be vector\n", combiner_to_string(combiner)); } if (errs) { if (verbose) fprintf(stderr, "aborting after %d errors\n", errs); return errs; } ints = malloc(nints * sizeof(*ints)); if (nadds) adds = malloc(nadds * sizeof(*adds)); types = malloc(ntypes * sizeof(*types)); err = MPI_Type_get_contents(inner_vector_copy, nints, nadds, ntypes, ints, adds, types); if (ints[0] != 2) errs++; if (ints[1] != 1) errs++; if (ints[2] != 2) errs++; if (verbose) { if (ints[0] != 2) fprintf(stderr, "inner vector count = %d; should be 2\n", ints[0]); if (ints[1] != 1) fprintf(stderr, "inner vector blocklength = %d; should be 1\n", ints[1]); if (ints[2] != 2) fprintf(stderr, "inner vector stride = %d; should be 2\n", ints[2]); } if (errs) { if (verbose) fprintf(stderr, "aborting after %d errors\n", errs); return errs; } free(ints); if (nadds) free(adds); free(types); MPI_Type_free( &inner_vector_copy ); MPI_Type_free( &inner_vector ); MPI_Type_free( &outer_vector ); return 0; } /* optimizable_vector_of_basics_test() * * Builds a vector of ints. Count is 10, blocksize is 2, stride is 2, so this * is equivalent to a contig of 20. But remember...we should get back our * suboptimal values under MPI-2. * * Returns the number of errors encountered. */ int optimizable_vector_of_basics_test(void) { MPI_Datatype parent_type; int nints, nadds, ntypes, combiner, *ints; MPI_Aint *adds = NULL; MPI_Datatype *types; int /* err, */ errs = 0; /* set up type */ /* err = */ MPI_Type_vector(10, 2, 2, MPI_INT, &parent_type); /* decode */ /* err = */ MPI_Type_get_envelope(parent_type, &nints, &nadds, &ntypes, &combiner); if (nints != 3) errs++; if (nadds != 0) errs++; if (ntypes != 1) errs++; if (combiner != MPI_COMBINER_VECTOR) errs++; if (verbose) { if (nints != 3) fprintf(stderr, "nints = %d; should be 3\n", nints); if (nadds != 0) fprintf(stderr, "nadds = %d; should be 0\n", nadds); if (ntypes != 1) fprintf(stderr, "ntypes = %d; should be 1\n", ntypes); if (combiner != MPI_COMBINER_VECTOR) fprintf(stderr, "combiner = %s; should be vector\n", combiner_to_string(combiner)); } ints = malloc(nints * sizeof(*ints)); if (nadds) adds = malloc(nadds * sizeof(*adds)); types = malloc(ntypes *sizeof(*types)); /* err = */ MPI_Type_get_contents(parent_type, nints, nadds, ntypes, ints, adds, types); if (ints[0] != 10) errs++; if (ints[1] != 2) errs++; if (ints[2] != 2) errs++; if (types[0] != MPI_INT) errs++; if (verbose) { if (ints[0] != 10) fprintf(stderr, "count = %d; should be 10\n", ints[0]); if (ints[1] != 2) fprintf(stderr, "blocklength = %d; should be 2\n", ints[1]); if (ints[2] != 2) fprintf(stderr, "stride = %d; should be 2\n", ints[2]); if (types[0] != MPI_INT) fprintf(stderr, "type is not MPI_INT\n"); } free(ints); if (nadds) free(adds); free(types); MPI_Type_free( &parent_type ); return errs; } /* indexed_of_basics_test(void) * * Simple indexed type. * * Returns number of errors encountered. */ int indexed_of_basics_test(void) { MPI_Datatype parent_type; int s_count = 3, s_blocklengths[3] = { 3, 2, 1 }; int s_displacements[3] = { 10, 20, 30 }; int nints, nadds, ntypes, combiner, *ints; MPI_Aint *adds = NULL; MPI_Datatype *types; int /* err, */ errs = 0; /* set up type */ /* err = */ MPI_Type_indexed(s_count, s_blocklengths, s_displacements, MPI_INT, &parent_type); /* decode */ /* err = */ MPI_Type_get_envelope(parent_type, &nints, &nadds, &ntypes, &combiner); if (nints != 7) errs++; if (nadds != 0) errs++; if (ntypes != 1) errs++; if (combiner != MPI_COMBINER_INDEXED) errs++; if (verbose) { if (nints != 7) fprintf(stderr, "nints = %d; should be 7\n", nints); if (nadds != 0) fprintf(stderr, "nadds = %d; should be 0\n", nadds); if (ntypes != 1) fprintf(stderr, "ntypes = %d; should be 1\n", ntypes); if (combiner != MPI_COMBINER_INDEXED) fprintf(stderr, "combiner = %s; should be indexed\n", combiner_to_string(combiner)); } ints = malloc(nints * sizeof(*ints)); if (nadds) adds = malloc(nadds * sizeof(*adds)); types = malloc(ntypes *sizeof(*types)); /* err = */ MPI_Type_get_contents(parent_type, nints, nadds, ntypes, ints, adds, types); if (ints[0] != s_count) errs++; if (ints[1] != s_blocklengths[0]) errs++; if (ints[2] != s_blocklengths[1]) errs++; if (ints[3] != s_blocklengths[2]) errs++; if (ints[4] != s_displacements[0]) errs++; if (ints[5] != s_displacements[1]) errs++; if (ints[6] != s_displacements[2]) errs++; if (types[0] != MPI_INT) errs++; if (verbose) { if (ints[0] != s_count) fprintf(stderr, "count = %d; should be %d\n", ints[0], s_count); if (ints[1] != s_blocklengths[0]) fprintf(stderr, "blocklength[0] = %d; should be %d\n", ints[1], s_blocklengths[0]); if (ints[2] != s_blocklengths[1]) fprintf(stderr, "blocklength[1] = %d; should be %d\n", ints[2], s_blocklengths[1]); if (ints[3] != s_blocklengths[2]) fprintf(stderr, "blocklength[2] = %d; should be %d\n", ints[3], s_blocklengths[2]); if (ints[4] != s_displacements[0]) fprintf(stderr, "displacement[0] = %d; should be %d\n", ints[4], s_displacements[0]); if (ints[5] != s_displacements[1]) fprintf(stderr, "displacement[1] = %d; should be %d\n", ints[5], s_displacements[1]); if (ints[6] != s_displacements[2]) fprintf(stderr, "displacement[2] = %d; should be %d\n", ints[6], s_displacements[2]); if (types[0] != MPI_INT) fprintf(stderr, "type[0] does not match\n"); } free(ints); if (nadds) free(adds); free(types); MPI_Type_free( &parent_type ); return errs; } /* indexed_of_vectors_test() * * Builds an indexed type of vectors of ints. * * Returns the number of errors encountered. */ int indexed_of_vectors_test(void) { MPI_Datatype inner_vector, inner_vector_copy; MPI_Datatype outer_indexed; int i_count = 3, i_blocklengths[3] = { 3, 2, 1 }; int i_displacements[3] = { 10, 20, 30 }; int nints, nadds, ntypes, combiner, *ints; MPI_Aint *adds = NULL; MPI_Datatype *types; int err, errs = 0; /* set up type */ err = MPI_Type_vector(2, 1, 2, MPI_INT, &inner_vector); if (err != MPI_SUCCESS) { if (verbose) fprintf(stderr, "error in MPI call; aborting after %d errors\n", errs+1); return errs+1; } err = MPI_Type_indexed(i_count, i_blocklengths, i_displacements, inner_vector, &outer_indexed); if (err != MPI_SUCCESS) { if (verbose) fprintf(stderr, "error in MPI call; aborting after %d errors\n", errs+1); return errs+1; } /* decode outer vector (get envelope, then contents) */ err = MPI_Type_get_envelope(outer_indexed, &nints, &nadds, &ntypes, &combiner); if (err != MPI_SUCCESS) { if (verbose) fprintf(stderr, "error in MPI call; aborting after %d errors\n", errs+1); return errs+1; } if (nints != 7) errs++; if (nadds != 0) errs++; if (ntypes != 1) errs++; if (combiner != MPI_COMBINER_INDEXED) errs++; if (verbose) { if (nints != 7) fprintf(stderr, "nints = %d; should be 7\n", nints); if (nadds != 0) fprintf(stderr, "nadds = %d; should be 0\n", nadds); if (ntypes != 1) fprintf(stderr, "ntypes = %d; should be 1\n", ntypes); if (combiner != MPI_COMBINER_INDEXED) fprintf(stderr, "combiner = %s; should be indexed\n", combiner_to_string(combiner)); } if (errs) { if (verbose) fprintf(stderr, "aborting after %d errors\n", errs); return errs; } ints = malloc(nints * sizeof(*ints)); if (nadds) adds = malloc(nadds * sizeof(*adds)); types = malloc(ntypes * sizeof(*types)); /* get contents of outer vector */ err = MPI_Type_get_contents(outer_indexed, nints, nadds, ntypes, ints, adds, types); if (ints[0] != i_count) errs++; if (ints[1] != i_blocklengths[0]) errs++; if (ints[2] != i_blocklengths[1]) errs++; if (ints[3] != i_blocklengths[2]) errs++; if (ints[4] != i_displacements[0]) errs++; if (ints[5] != i_displacements[1]) errs++; if (ints[6] != i_displacements[2]) errs++; if (verbose) { if (ints[0] != i_count) fprintf(stderr, "count = %d; should be %d\n", ints[0], i_count); if (ints[1] != i_blocklengths[0]) fprintf(stderr, "blocklength[0] = %d; should be %d\n", ints[1], i_blocklengths[0]); if (ints[2] != i_blocklengths[1]) fprintf(stderr, "blocklength[1] = %d; should be %d\n", ints[2], i_blocklengths[1]); if (ints[3] != i_blocklengths[2]) fprintf(stderr, "blocklength[2] = %d; should be %d\n", ints[3], i_blocklengths[2]); if (ints[4] != i_displacements[0]) fprintf(stderr, "displacement[0] = %d; should be %d\n", ints[4], i_displacements[0]); if (ints[5] != i_displacements[1]) fprintf(stderr, "displacement[1] = %d; should be %d\n", ints[5], i_displacements[1]); if (ints[6] != i_displacements[2]) fprintf(stderr, "displacement[2] = %d; should be %d\n", ints[6], i_displacements[2]); } if (errs) { if (verbose) fprintf(stderr, "aborting after %d errors\n", errs); return errs; } inner_vector_copy = types[0]; free(ints); if (nadds) free(adds); free(types); /* decode inner vector */ err = MPI_Type_get_envelope(inner_vector_copy, &nints, &nadds, &ntypes, &combiner); if (err != MPI_SUCCESS) { if (verbose) fprintf(stderr, "error in MPI call; aborting after %d errors\n", errs+1); return errs+1; } if (nints != 3) errs++; if (nadds != 0) errs++; if (ntypes != 1) errs++; if (combiner != MPI_COMBINER_VECTOR) errs++; if (verbose) { if (nints != 3) fprintf(stderr, "inner vector nints = %d; should be 3\n", nints); if (nadds != 0) fprintf(stderr, "inner vector nadds = %d; should be 0\n", nadds); if (ntypes != 1) fprintf(stderr, "inner vector ntypes = %d; should be 1\n", ntypes); if (combiner != MPI_COMBINER_VECTOR) fprintf(stderr, "inner vector combiner = %s; should be vector\n", combiner_to_string(combiner)); } if (errs) { if (verbose) fprintf(stderr, "aborting after %d errors\n", errs); return errs; } ints = malloc(nints * sizeof(*ints)); if (nadds) adds = malloc(nadds * sizeof(*adds)); types = malloc(ntypes * sizeof(*types)); err = MPI_Type_get_contents(inner_vector_copy, nints, nadds, ntypes, ints, adds, types); if (ints[0] != 2) errs++; if (ints[1] != 1) errs++; if (ints[2] != 2) errs++; if (verbose) { if (ints[0] != 2) fprintf(stderr, "inner vector count = %d; should be 2\n", ints[0]); if (ints[1] != 1) fprintf(stderr, "inner vector blocklength = %d; should be 1\n", ints[1]); if (ints[2] != 2) fprintf(stderr, "inner vector stride = %d; should be 2\n", ints[2]); } if (errs) { if (verbose) fprintf(stderr, "aborting after %d errors\n", errs); return errs; } free(ints); if (nadds) free(adds); free(types); MPI_Type_free( &inner_vector_copy ); MPI_Type_free( &inner_vector ); MPI_Type_free( &outer_indexed ); return 0; } #ifdef HAVE_MPI_TYPE_CREATE_STRUCT /* struct_of_basics_test(void) * * There's nothing simple about structs :). Although this is an easy one. * * Returns number of errors encountered. * * NOT TESTED. */ int struct_of_basics_test(void) { MPI_Datatype parent_type; int s_count = 3, s_blocklengths[3] = { 3, 2, 1 }; MPI_Aint s_displacements[3] = { 10, 20, 30 }; MPI_Datatype s_types[3] = { MPI_CHAR, MPI_INT, MPI_FLOAT }; int nints, nadds, ntypes, combiner, *ints; MPI_Aint *adds = NULL; MPI_Datatype *types; int err, errs = 0; /* set up type */ err = MPI_Type_create_struct(s_count, s_blocklengths, s_displacements, s_types, &parent_type); /* decode */ err = MPI_Type_get_envelope(parent_type, &nints, &nadds, &ntypes, &combiner); if (nints != 4) errs++; if (nadds != 3) errs++; if (ntypes != 3) errs++; if (combiner != MPI_COMBINER_STRUCT) errs++; if (verbose) { if (nints != 4) fprintf(stderr, "nints = %d; should be 3\n", nints); if (nadds != 3) fprintf(stderr, "nadds = %d; should be 0\n", nadds); if (ntypes != 3) fprintf(stderr, "ntypes = %d; should be 3\n", ntypes); if (combiner != MPI_COMBINER_STRUCT) fprintf(stderr, "combiner = %s; should be struct\n", combiner_to_string(combiner)); } ints = malloc(nints * sizeof(*ints)); adds = malloc(nadds * sizeof(*adds)); types = malloc(ntypes *sizeof(*types)); err = MPI_Type_get_contents(parent_type, nints, nadds, ntypes, ints, adds, types); if (ints[0] != s_count) errs++; if (ints[1] != s_blocklengths[0]) errs++; if (ints[2] != s_blocklengths[1]) errs++; if (ints[3] != s_blocklengths[2]) errs++; if (adds[0] != s_displacements[0]) errs++; if (adds[1] != s_displacements[1]) errs++; if (adds[2] != s_displacements[2]) errs++; if (types[0] != s_types[0]) errs++; if (types[1] != s_types[1]) errs++; if (types[2] != s_types[2]) errs++; if (verbose) { if (ints[0] != s_count) fprintf(stderr, "count = %d; should be %d\n", ints[0], s_count); if (ints[1] != s_blocklengths[0]) fprintf(stderr, "blocklength[0] = %d; should be %d\n", ints[1], s_blocklengths[0]); if (ints[2] != s_blocklengths[1]) fprintf(stderr, "blocklength[1] = %d; should be %d\n", ints[2], s_blocklengths[1]); if (ints[3] != s_blocklengths[2]) fprintf(stderr, "blocklength[2] = %d; should be %d\n", ints[3], s_blocklengths[2]); if (adds[0] != s_displacements[0]) fprintf(stderr, "displacement[0] = %d; should be %d\n", adds[0], s_displacements[0]); if (adds[1] != s_displacements[1]) fprintf(stderr, "displacement[1] = %d; should be %d\n", adds[1], s_displacements[1]); if (adds[2] != s_displacements[2]) fprintf(stderr, "displacement[2] = %d; should be %d\n", adds[2], s_displacements[2]); if (types[0] != s_types[0]) fprintf(stderr, "type[0] does not match\n"); if (types[1] != s_types[1]) fprintf(stderr, "type[1] does not match\n"); if (types[2] != s_types[2]) fprintf(stderr, "type[2] does not match\n"); } free(ints); free(adds); free(types); MPI_Type_free( &parent_type ); return errs; } #endif /* combiner_to_string(combiner) * * Converts a numeric combiner into a pointer to a string used for printing. */ char *combiner_to_string(int combiner) { static char c_named[] = "named"; static char c_contig[] = "contig"; static char c_vector[] = "vector"; static char c_hvector[] = "hvector"; static char c_indexed[] = "indexed"; static char c_hindexed[] = "hindexed"; static char c_struct[] = "struct"; #ifdef HAVE_MPI2_COMBINERS static char c_dup[] = "dup"; static char c_hvector_integer[] = "hvector_integer"; static char c_hindexed_integer[] = "hindexed_integer"; static char c_indexed_block[] = "indexed_block"; static char c_struct_integer[] = "struct_integer"; static char c_subarray[] = "subarray"; static char c_darray[] = "darray"; static char c_f90_real[] = "f90_real"; static char c_f90_complex[] = "f90_complex"; static char c_f90_integer[] = "f90_integer"; static char c_resized[] = "resized"; #endif if (combiner == MPI_COMBINER_NAMED) return c_named; if (combiner == MPI_COMBINER_CONTIGUOUS) return c_contig; if (combiner == MPI_COMBINER_VECTOR) return c_vector; if (combiner == MPI_COMBINER_HVECTOR) return c_hvector; if (combiner == MPI_COMBINER_INDEXED) return c_indexed; if (combiner == MPI_COMBINER_HINDEXED) return c_hindexed; if (combiner == MPI_COMBINER_STRUCT) return c_struct; #ifdef HAVE_MPI2_COMBINERS if (combiner == MPI_COMBINER_DUP) return c_dup; if (combiner == MPI_COMBINER_HVECTOR_INTEGER) return c_hvector_integer; if (combiner == MPI_COMBINER_HINDEXED_INTEGER) return c_hindexed_integer; if (combiner == MPI_COMBINER_INDEXED_BLOCK) return c_indexed_block; if (combiner == MPI_COMBINER_STRUCT_INTEGER) return c_struct_integer; if (combiner == MPI_COMBINER_SUBARRAY) return c_subarray; if (combiner == MPI_COMBINER_DARRAY) return c_darray; if (combiner == MPI_COMBINER_F90_REAL) return c_f90_real; if (combiner == MPI_COMBINER_F90_COMPLEX) return c_f90_complex; if (combiner == MPI_COMBINER_F90_INTEGER) return c_f90_integer; if (combiner == MPI_COMBINER_RESIZED) return c_resized; #endif return NULL; } int parse_args(int argc, char **argv) { #ifdef HAVE_GET_OPT int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } #else #endif return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/typelb.c000644 001750 001750 00000002465 12342443662 022444 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include int main( int argc, char **argv) { int blockcnt[2], rank; MPI_Aint offsets[2], lb, ub, extent; MPI_Datatype tmp_type, newtype; MPI_Init(&argc, &argv); /* Set some values in locations that should not be accessed */ blockcnt[1] = -1; offsets[1] = -1; MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (rank == 0) { blockcnt[0] = 1; offsets[0] = 3; MPI_Type_hindexed(1, blockcnt, offsets, MPI_BYTE, &tmp_type); blockcnt[0] = 1; offsets[0] = 1; MPI_Type_hindexed(1, blockcnt, offsets, tmp_type, &newtype); MPI_Type_commit(&newtype); MPI_Type_lb(newtype, &lb); MPI_Type_extent(newtype, &extent); MPI_Type_ub(newtype, &ub); /* Check that the results are correct */ #ifdef DEBUG printf("lb=%ld, ub=%ld, extent=%ld\n", lb, ub, extent); printf("Should be lb=4, ub=5, extent=1\n"); #endif if (lb != 4 || ub != 5 || extent != 1) { printf ("lb = %d (should be 4), ub = %d (should be 5) extent = %d should be 1\n", (int)lb, (int)ub, (int)extent) ; } else { printf( " No Errors\n" ); } MPI_Type_free(&tmp_type); MPI_Type_free(&newtype); } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/typefree.c000644 001750 001750 00000001635 12342443662 022766 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2007 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitest.h" #include #include #include /* * This test may be used to confirm that memory is properly recovered from * freed datatypes. To test this, build the MPI implementation with memory * leak checking. As this program may be run with a single process, it should * also be easy to run it under valgrind or a similar program. With MPICH, * you can configure with the option * * --enable-g=mem * * to turn on MPICH's internal memory checking. */ int main( int argc, char *argv[] ) { int errs = 0; MPI_Datatype type; MTest_Init( &argc, &argv ); MPI_Type_dup( MPI_INT, &type ); MPI_Type_free( &type ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/simple-commit.c000644 001750 001750 00000003025 12342443662 023715 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* Tests that commit of a couple of basic types succeeds. */ #include "mpi.h" #include #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 0; int parse_args(int argc, char **argv); int main(int argc, char **argv) { int mpi_err, errs = 0; MPI_Datatype type; MPI_Init(&argc, &argv); parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); type = MPI_INT; mpi_err = MPI_Type_commit(&type); if (mpi_err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "MPI_Type_commit of MPI_INT failed.\n"); } errs++; } type = MPI_FLOAT_INT; mpi_err = MPI_Type_commit(&type); if (mpi_err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "MPI_Type_commit of MPI_FLOAT_INT failed.\n"); } errs++; } /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/unpack.c000644 001750 001750 00000005736 12342443662 022432 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" #include #include /* Test sent in by Avery Ching to report a bug in MPICH. Adding it as a regression test. */ /* static void print_char_buf(char *buf_name, char *buf, int buf_len) { int i; printf("print_char_buf: %s\n", buf_name); for (i = 0; i < buf_len; i++) { printf("%c ", buf[i]); if (((i + 1) % 10) == 0) printf("\n"); else if (((i + 1) % 5) == 0) printf(" "); } printf("\n"); } */ char correct_buf[] = {'a', '_', 'b', 'c', '_', '_', '_', '_', 'd', '_', 'e', 'f', 'g', '_', 'h', 'i', 'j', '_', 'k', 'l', '_', '_', '_', '_', 'm', '_', 'n', 'o', 'p', '_', 'q', 'r'}; #define COUNT 2 int main(int argc, char **argv) { int myid, numprocs, i; char *mem_buf = NULL, *unpack_buf = NULL; MPI_Datatype tmp_dtype, mem_dtype; MPI_Aint mem_dtype_ext = -1; int mem_dtype_sz = -1; int mem_buf_sz = -1, unpack_buf_sz = -1, buf_pos = 0; int blk_arr[COUNT] = {1, 2}; int dsp_arr[COUNT] = {0, 2}; int errs = 0; MTest_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &myid); MPI_Comm_size(MPI_COMM_WORLD, &numprocs); /* Creating the datatype to use for unpacking */ MPI_Type_indexed(COUNT, blk_arr, dsp_arr, MPI_CHAR, &tmp_dtype); MPI_Type_commit(&tmp_dtype); MPI_Type_indexed(COUNT, blk_arr, dsp_arr, tmp_dtype, &mem_dtype); MPI_Type_free( &tmp_dtype ); MPI_Type_commit(&mem_dtype); MPI_Type_size(mem_dtype, &mem_dtype_sz); MPI_Type_extent(mem_dtype, &mem_dtype_ext); mem_buf_sz = 2 * mem_dtype_ext; unpack_buf_sz = 2 * mem_dtype_sz; if ((mem_buf = (char *) malloc(mem_buf_sz)) == NULL) { fprintf(stderr, "malloc mem_buf of size %d failed\n", mem_buf_sz); return -1; } memset(mem_buf, '_', mem_buf_sz); if ((unpack_buf = (char *) malloc(unpack_buf_sz)) == NULL) { fprintf(stderr, "malloc unpack_buf of size %d failed\n", unpack_buf_sz); return -1; } for (i = 0; i < unpack_buf_sz; i++) unpack_buf[i] = 'a' + i; /* print_char_buf("mem_buf before unpack", mem_buf, 2 * mem_dtype_ext); */ MPI_Unpack(unpack_buf, unpack_buf_sz, &buf_pos, mem_buf, 2, mem_dtype, MPI_COMM_SELF); /* Note: Unpack without a Pack is not technically correct, but should work * with MPICH. */ /* print_char_buf("mem_buf after unpack", mem_buf, 2 * mem_dtype_ext); print_char_buf("correct buffer should be", correct_buf, 2 * mem_dtype_ext); */ if (memcmp(mem_buf, correct_buf, 2 * mem_dtype_ext)) { printf("Unpacked buffer does not match expected buffer\n"); errs++; } MPI_Type_free(&mem_dtype); MTest_Finalize(errs); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/typename.c000644 001750 001750 00000014764 12342443662 022774 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitest.h" #include #include /* Create an array with all of the MPI names in it */ typedef struct mpi_names_t { MPI_Datatype dtype; const char *name; } mpi_names_t; /* The MPI standard specifies that the names must be the MPI names, not the related language names (e.g., MPI_CHAR, not char) */ int main( int argc, char **argv ) { mpi_names_t mpi_names[] = { { MPI_CHAR, "MPI_CHAR" }, { MPI_SIGNED_CHAR, "MPI_SIGNED_CHAR" }, { MPI_UNSIGNED_CHAR, "MPI_UNSIGNED_CHAR" }, { MPI_BYTE, "MPI_BYTE" }, { MPI_WCHAR, "MPI_WCHAR" }, { MPI_SHORT, "MPI_SHORT" }, { MPI_UNSIGNED_SHORT, "MPI_UNSIGNED_SHORT" }, { MPI_INT, "MPI_INT" }, { MPI_UNSIGNED, "MPI_UNSIGNED" }, { MPI_LONG, "MPI_LONG" }, { MPI_UNSIGNED_LONG, "MPI_UNSIGNED_LONG" }, { MPI_FLOAT, "MPI_FLOAT" }, { MPI_DOUBLE, "MPI_DOUBLE" }, #if MTEST_HAVE_MIN_MPI_VERSION(2,2) /* these two types were added in MPI-2.2 */ { MPI_AINT, "MPI_AINT" }, { MPI_OFFSET, "MPI_OFFSET" }, #endif { MPI_PACKED, "MPI_PACKED" }, { MPI_LB, "MPI_LB" }, { MPI_UB, "MPI_UB" }, { MPI_FLOAT_INT, "MPI_FLOAT_INT" }, { MPI_DOUBLE_INT, "MPI_DOUBLE_INT" }, { MPI_LONG_INT, "MPI_LONG_INT" }, { MPI_SHORT_INT, "MPI_SHORT_INT" }, { MPI_2INT, "MPI_2INT" }, /* Fortran */ #ifdef HAVE_FORTRAN_BINDING { MPI_COMPLEX, "MPI_COMPLEX" }, { MPI_DOUBLE_COMPLEX, "MPI_DOUBLE_COMPLEX" }, { MPI_LOGICAL, "MPI_LOGICAL" }, { MPI_REAL, "MPI_REAL" }, { MPI_DOUBLE_PRECISION, "MPI_DOUBLE_PRECISION" }, { MPI_INTEGER, "MPI_INTEGER" }, { MPI_2INTEGER, "MPI_2INTEGER" }, /* 2COMPLEX (and the 2DOUBLE_COMPLEX) were in MPI 1.0 but not later */ #ifdef HAVE_MPI_2COMPLEX { MPI_2COMPLEX, "MPI_2COMPLEX" }, #endif #ifdef HAVE_MPI_2DOUBLE_COMPLEX /* MPI_2DOUBLE_COMPLEX is an extension - it is not part of MPI 2.1 */ { MPI_2DOUBLE_COMPLEX, "MPI_2DOUBLE_COMPLEX" }, #endif { MPI_2REAL, "MPI_2REAL" }, { MPI_2DOUBLE_PRECISION, "MPI_2DOUBLE_PRECISION" }, { MPI_CHARACTER, "MPI_CHARACTER" }, #endif #if MTEST_HAVE_MIN_MPI_VERSION(2,2) /* these C99 types were added in MPI-2.2 */ { MPI_INT8_T, "MPI_INT8_T" }, { MPI_INT16_T, "MPI_INT16_T" }, { MPI_INT32_T, "MPI_INT32_T" }, { MPI_INT64_T, "MPI_INT64_T" }, { MPI_UINT8_T, "MPI_UINT8_T" }, { MPI_UINT16_T, "MPI_UINT16_T" }, { MPI_UINT32_T, "MPI_UINT32_T" }, { MPI_UINT64_T, "MPI_UINT64_T" }, { MPI_C_BOOL, "MPI_C_BOOL" }, { MPI_C_FLOAT_COMPLEX, "MPI_C_FLOAT_COMPLEX" }, { MPI_C_DOUBLE_COMPLEX, "MPI_C_DOUBLE_COMPLEX" }, { MPI_AINT, "MPI_AINT" }, { MPI_OFFSET, "MPI_OFFSET" }, #endif /* Size-specific types */ /* Do not move MPI_REAL4 - this is used to indicate the very first optional type. In addition, you must not add any required types after this type */ /* See MPI 2.1, Section 16.2. These are required, predefined types. If the type is not available (e.g., *only* because the Fortran compiler does not support it), the value may be MPI_DATATYPE_NULL */ { MPI_REAL4, "MPI_REAL4" }, { MPI_REAL8, "MPI_REAL8" }, { MPI_REAL16, "MPI_REAL16" }, { MPI_COMPLEX8, "MPI_COMPLEX8" }, { MPI_COMPLEX16, "MPI_COMPLEX16" }, { MPI_COMPLEX32, "MPI_COMPLEX32" }, { MPI_INTEGER1, "MPI_INTEGER1" }, { MPI_INTEGER2, "MPI_INTEGER2" }, { MPI_INTEGER4, "MPI_INTEGER4" }, { MPI_INTEGER8, "MPI_INTEGER8" }, #ifdef HAVE_MPI_INTEGER16 /* MPI_INTEGER16 is not included in most of the tables in MPI 2.1, and some implementations omit it. An error will be reported, but this ifdef allows the test to be built and run. */ { MPI_INTEGER16, "MPI_INTEGER16" }, #endif /* Semi-optional types - if the compiler doesn't support long double or long long, these might be MPI_DATATYPE_NULL */ { MPI_LONG_DOUBLE, "MPI_LONG_DOUBLE" }, { MPI_LONG_LONG_INT, "MPI_LONG_LONG_INT" }, { MPI_LONG_LONG, "MPI_LONG_LONG" }, { MPI_UNSIGNED_LONG_LONG, "MPI_UNSIGNED_LONG_LONG" }, { MPI_LONG_DOUBLE_INT, "MPI_LONG_DOUBLE_INT" }, #if MTEST_HAVE_MIN_MPI_VERSION(2,2) /* added in MPI-2.2 */ { MPI_C_LONG_DOUBLE_COMPLEX, "MPI_C_LONG_DOUBLE_COMPLEX" }, { MPI_AINT, "MPI_AINT" }, { MPI_OFFSET, "MPI_OFFSET" }, #endif #if MTEST_HAVE_MIN_MPI_VERSION(3,0) /* added in MPI 3 */ { MPI_COUNT, "MPI_COUNT" }, #endif { 0, (char *)0 }, /* Sentinal used to indicate the last element */ }; char name[MPI_MAX_OBJECT_NAME]; int namelen, i, inOptional; int errs = 0; MTest_Init( &argc, &argv ); /* Sample some datatypes */ /* See 8.4, "Naming Objects" in MPI-2. The default name is the same as the datatype name */ MPI_Type_get_name( MPI_DOUBLE, name, &namelen ); if (strncmp( name, "MPI_DOUBLE", MPI_MAX_OBJECT_NAME )) { errs++; fprintf( stderr, "Expected MPI_DOUBLE but got :%s:\n", name ); } MPI_Type_get_name( MPI_INT, name, &namelen ); if (strncmp( name, "MPI_INT", MPI_MAX_OBJECT_NAME )) { errs++; fprintf( stderr, "Expected MPI_INT but got :%s:\n", name ); } /* Now we try them ALL */ inOptional = 0; for (i=0; mpi_names[i].name != 0; i++) { /* Are we in the optional types? */ if (strcmp( mpi_names[i].name, "MPI_REAL4" ) == 0) inOptional = 1; /* If this optional type is not supported, skip it */ if (inOptional && mpi_names[i].dtype == MPI_DATATYPE_NULL) continue; if (mpi_names[i].dtype == MPI_DATATYPE_NULL) { /* Report an error because all of the standard types must be supported */ errs++; fprintf( stderr, "MPI Datatype %s is MPI_DATATYPE_NULL\n", mpi_names[i].name ); continue; } MTestPrintfMsg( 10, "Checking type %s\n", mpi_names[i].name ); name[0] = 0; MPI_Type_get_name( mpi_names[i].dtype, name, &namelen ); if (strncmp( name, mpi_names[i].name, namelen )) { errs++; fprintf( stderr, "Expected %s but got %s\n", mpi_names[i].name, name ); } } /* Try resetting the name */ MPI_Type_set_name( MPI_INT, (char*)"int" ); name[0] = 0; MPI_Type_get_name( MPI_INT, name, &namelen ); if (strncmp( name, "int", MPI_MAX_OBJECT_NAME )) { errs++; fprintf( stderr, "Expected int but got :%s:\n", name ); } #ifndef HAVE_MPI_INTEGER16 errs++; fprintf( stderr, "MPI_INTEGER16 is not available\n" ); #endif MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/contigstruct.c000644 001750 001750 00000002351 12342443662 023667 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include /* * This test checks to see if we can create a simple datatype * made from many contiguous copies of a single struct. The * struct is built with monotone decreasing displacements to * avoid any struct->contig optimizations. */ int main( int argc, char **argv ) { int blocklens[8], psize, i, rank; MPI_Aint displs[8]; MPI_Datatype oldtypes[8]; MPI_Datatype ntype1, ntype2; MPI_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); for (i=0; i<8; i++) { blocklens[i] = 1; displs[i] = (7-i) * sizeof(long); oldtypes[i] = MPI_LONG; } MPI_Type_struct( 8, blocklens, displs, oldtypes, &ntype1 ); MPI_Type_contiguous( 65536, ntype1, &ntype2 ); MPI_Type_commit( &ntype2 ); MPI_Pack_size( 2, ntype2, MPI_COMM_WORLD, &psize ); MPI_Type_free( &ntype2 ); MPI_Type_free( &ntype1 ); /* The only failure mode has been SEGV or aborts within the datatype routines */ if (rank == 0) { printf( " No Errors\n" ); } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/lbub.c000644 001750 001750 00000104470 12342443662 022070 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif /* The default behavior of the test routines should be to briefly indicate the cause of any errors - in this test, that means that verbose needs to be set. Verbose should turn on output that is independent of error levels. */ static int verbose = 1; /* tests */ int int_with_lb_ub_test(void); int contig_of_int_with_lb_ub_test(void); int contig_negextent_of_int_with_lb_ub_test(void); int vector_of_int_with_lb_ub_test(void); int vector_blklen_of_int_with_lb_ub_test(void); int vector_blklen_stride_of_int_with_lb_ub_test(void); int vector_blklen_stride_negextent_of_int_with_lb_ub_test(void); int vector_blklen_negstride_negextent_of_int_with_lb_ub_test(void); int int_with_negextent_test(void); int vector_blklen_negstride_of_int_with_lb_ub_test(void); /* helper functions */ int parse_args(int argc, char **argv); int main(int argc, char **argv) { int err, errs = 0; MTest_Init( &argc, &argv ); parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = int_with_lb_ub_test(); if (err && verbose) fprintf(stderr, "found %d errors in simple lb/ub test\n", err); errs += err; err = contig_of_int_with_lb_ub_test(); if (err && verbose) fprintf(stderr, "found %d errors in contig test\n", err); errs += err; err = contig_negextent_of_int_with_lb_ub_test(); if (err && verbose) fprintf(stderr, "found %d errors in negextent contig test\n", err); errs += err; err = vector_of_int_with_lb_ub_test(); if (err && verbose) fprintf(stderr, "found %d errors in simple vector test\n", err); errs += err; err = vector_blklen_of_int_with_lb_ub_test(); if (err && verbose) fprintf(stderr, "found %d errors in vector blklen test\n", err); errs += err; err = vector_blklen_stride_of_int_with_lb_ub_test(); if (err && verbose) fprintf(stderr, "found %d errors in strided vector test\n", err); errs += err; err = vector_blklen_negstride_of_int_with_lb_ub_test(); if (err && verbose) fprintf(stderr, "found %d errors in negstrided vector test\n", err); errs += err; err = int_with_negextent_test(); if (err && verbose) fprintf(stderr, "found %d errors in negextent lb/ub test\n", err); errs += err; err = vector_blklen_stride_negextent_of_int_with_lb_ub_test(); if (err && verbose) fprintf(stderr, "found %d errors in strided negextent vector test\n", err); errs += err; err = vector_blklen_negstride_negextent_of_int_with_lb_ub_test(); if (err && verbose) fprintf(stderr, "found %d errors in negstrided negextent vector test\n", err); errs += err; MTest_Finalize( errs ); MPI_Finalize(); return 0; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } int int_with_lb_ub_test(void) { int err, errs = 0, val; MPI_Aint lb, extent, aval, true_lb; int blocks[3] = { 1, 4, 1 }; MPI_Aint disps[3] = { -3, 0, 6 }; MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB }; MPI_Datatype eviltype; err = MPI_Type_struct(3, blocks, disps, types, &eviltype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_struct failed.\n"); if (verbose) MTestPrintError( err ); } err = MPI_Type_size(eviltype, &val); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_size failed.\n"); if (verbose) MTestPrintError( err ); } if (val != 4) { errs++; if (verbose) fprintf(stderr, " size of type = %d; should be %d\n", val, 4); } err = MPI_Type_extent(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 9) { errs++; if (verbose) fprintf(stderr, " extent of type = %ld; should be %d\n", (long) aval, 9); } err = MPI_Type_lb(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_lb failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -3) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -3); } err = MPI_Type_get_extent(eviltype, &lb, &extent); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (lb != -3) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -3); } if (extent != 9) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) extent, 9); } err = MPI_Type_ub(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_ub failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 6) { errs++; if (verbose) fprintf(stderr, " ub of type = %d; should be %d\n", (int) aval, 6); } err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_true_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (true_lb != 0) { errs++; if (verbose) fprintf(stderr, " true_lb of type = %d; should be %d\n", (int) true_lb, 0); } if (aval != 4) { errs++; if (verbose) fprintf(stderr, " true extent of type = %d; should be %d\n", (int) aval, 4); } MPI_Type_free(&eviltype); return errs; } int contig_of_int_with_lb_ub_test(void) { int err, errs = 0, val; MPI_Aint lb, extent, aval, true_lb; int blocks[3] = { 1, 4, 1 }; MPI_Aint disps[3] = { -3, 0, 6 }; MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB }; char *typemapstring = 0; MPI_Datatype inttype, eviltype; /* build same type as in int_with_lb_ub_test() */ typemapstring = (char*)"{ (LB,-3),4*(BYTE,0),(UB,6) }"; err = MPI_Type_struct(3, blocks, disps, types, &inttype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_struct of %s failed.\n", typemapstring ); if (verbose) MTestPrintError( err ); /* no point in continuing */ return errs; } typemapstring=(char*)"{ (LB,-3),4*(BYTE,0),(UB,6),(LB,6),4*(BYTE,9),(UB,15),(LB,15),4*(BYTE,18),(UB,24)}"; err = MPI_Type_contiguous(3, inttype, &eviltype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_contiguous of %s failed.\n", typemapstring ); if (verbose) MTestPrintError( err ); /* no point in continuing */ return errs; } err = MPI_Type_size(eviltype, &val); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_size of %s failed.\n", typemapstring ); if (verbose) MTestPrintError( err ); } if (val != 12) { errs++; if (verbose) fprintf(stderr, " size of type = %d; should be %d\n", val, 12); } err = MPI_Type_extent(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 27) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) aval, 27); if (verbose) fprintf( stderr, " for type %s\n", typemapstring ); } err = MPI_Type_lb(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_lb failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -3) { errs++; if (verbose) fprintf(stderr, " lb of type = %d from Type_lb; should be %d in %s\n", (int) aval, -3, typemapstring ); } err = MPI_Type_get_extent(eviltype, &lb, &extent); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (lb != -3) { errs++; if (verbose) fprintf(stderr, " lb of type = %d from Type_get_extent; should be %d in %s\n", (int) aval, -3, typemapstring ); } if (extent != 27) { errs++; if (verbose) fprintf(stderr, " extent of type = %d from Type_get_extent; should be %d in %s\n", (int) extent, 27, typemapstring); } err = MPI_Type_ub(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_ub failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 24) { errs++; if (verbose) fprintf(stderr, " ub of type = %d in Type_ub; should be %din %s\n", (int) aval, 24, typemapstring); } err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_true_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (true_lb != 0) { errs++; if (verbose) fprintf(stderr, " true_lb of type = %d; should be %d in %s\n", (int) true_lb, 0, typemapstring); } if (aval != 22) { errs++; if (verbose) fprintf(stderr, " true extent of type = %d; should be %d in %s\n", (int) aval, 22, typemapstring); } MPI_Type_free( &inttype ); MPI_Type_free( &eviltype ); return errs; } int contig_negextent_of_int_with_lb_ub_test(void) { int err, errs = 0, val; MPI_Aint lb, extent, aval, true_lb; int blocks[3] = { 1, 4, 1 }; MPI_Aint disps[3] = { 6, 0, -3 }; MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB }; char *typemapstring = 0; MPI_Datatype inttype, eviltype; /* build same type as in int_with_lb_ub_test() */ typemapstring = (char*)"{ (LB,6),4*(BYTE,0),(UB,-3) }"; err = MPI_Type_struct(3, blocks, disps, types, &inttype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_struct of %s failed.\n", typemapstring ); if (verbose) MTestPrintError( err ); /* No point in continuing */ return errs; } typemapstring = (char*)"{ (LB,6),4*(BYTE,0),(UB,-3),(LB,-3),4*(BYTE,-9),(UB,-12),(LB,-12),4*(BYTE,-18),(UB,-21) }"; err = MPI_Type_contiguous(3, inttype, &eviltype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_contiguous of %s failed.\n", typemapstring); if (verbose) MTestPrintError( err ); /* No point in continuing */ return errs; } err = MPI_Type_size(eviltype, &val); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_size of %s failed.\n", typemapstring); if (verbose) MTestPrintError( err ); } if (val != 12) { errs++; if (verbose) fprintf(stderr, " size of type = %d; should be %d\n", val, 12); } err = MPI_Type_extent(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 9) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) aval, 9); } err = MPI_Type_lb(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_lb failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -12) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -12); } err = MPI_Type_get_extent(eviltype, &lb, &extent); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (lb != -12) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -12); } if (extent != 9) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) extent, 9); } err = MPI_Type_ub(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_ub failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -3) { errs++; if (verbose) fprintf(stderr, " ub of type = %d; should be %d\n", (int) aval, -3); } err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_true_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (true_lb != -18) { errs++; if (verbose) fprintf(stderr, " true_lb of type = %d; should be %d\n", (int) true_lb, -18); } if (aval != 22) { errs++; if (verbose) fprintf(stderr, " true extent of type = %d; should be %d\n", (int) aval, 22); } MPI_Type_free( &inttype ); MPI_Type_free( &eviltype ); return errs; } int vector_of_int_with_lb_ub_test(void) { int err, errs = 0, val; MPI_Aint lb, extent, aval, true_lb; int blocks[3] = { 1, 4, 1 }; MPI_Aint disps[3] = { -3, 0, 6 }; MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB }; MPI_Datatype inttype, eviltype; /* build same type as in int_with_lb_ub_test() */ err = MPI_Type_struct(3, blocks, disps, types, &inttype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_struct failed.\n"); if (verbose) MTestPrintError( err ); /* no point in continuing */ return errs; } err = MPI_Type_vector(3, 1, 1, inttype, &eviltype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_vector failed.\n"); if (verbose) MTestPrintError( err ); /* no point in continuing */ return errs; } err = MPI_Type_size(eviltype, &val); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_size failed.\n"); if (verbose) MTestPrintError( err ); } if (val != 12) { errs++; if (verbose) fprintf(stderr, " size of type = %d; should be %d\n", val, 12); } err = MPI_Type_extent(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 27) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) aval, 27); } err = MPI_Type_lb(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_lb failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -3) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -3); } err = MPI_Type_get_extent(eviltype, &lb, &extent); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (lb != -3) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -3); } if (extent != 27) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) extent, 27); } err = MPI_Type_ub(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_ub failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 24) { errs++; if (verbose) fprintf(stderr, " ub of type = %d; should be %d\n", (int) aval, 24); } err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_true_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (true_lb != 0) { errs++; if (verbose) fprintf(stderr, " true_lb of type = %d; should be %d\n", (int) true_lb, 0); } if (aval != 22) { errs++; if (verbose) fprintf(stderr, " true extent of type = %d; should be %d\n", (int) aval, 22); } MPI_Type_free( &inttype ); MPI_Type_free( &eviltype ); return errs; } /* * blklen = 4 */ int vector_blklen_of_int_with_lb_ub_test(void) { int err, errs = 0, val; MPI_Aint lb, extent, aval, true_lb; int blocks[3] = { 1, 4, 1 }; MPI_Aint disps[3] = { -3, 0, 6 }; MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB }; MPI_Datatype inttype, eviltype; /* build same type as in int_with_lb_ub_test() */ err = MPI_Type_struct(3, blocks, disps, types, &inttype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_struct failed.\n"); if (verbose) MTestPrintError( err ); /* no point in continuing */ return errs; } err = MPI_Type_vector(3, 4, 1, inttype, &eviltype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_vector failed.\n"); if (verbose) MTestPrintError( err ); /* no point in continuing */ return errs; } err = MPI_Type_size(eviltype, &val); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_size failed.\n"); if (verbose) MTestPrintError( err ); } if (val != 48) { errs++; if (verbose) fprintf(stderr, " size of type = %d; should be %d\n", val, 48); } err = MPI_Type_extent(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 54) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) aval, 54); } err = MPI_Type_lb(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_lb failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -3) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -3); if (verbose) MTestPrintError( err ); } err = MPI_Type_get_extent(eviltype, &lb, &extent); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (lb != -3) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -3); } if (extent != 54) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) extent, 54); } err = MPI_Type_ub(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_ub failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 51) { errs++; if (verbose) fprintf(stderr, " ub of type = %d; should be %d\n", (int) aval, 51); } err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_true_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (true_lb != 0) { errs++; if (verbose) fprintf(stderr, " true_lb of type = %d; should be %d\n", (int) true_lb, 0); } if (aval != 49) { errs++; if (verbose) fprintf(stderr, " true extent of type = %d; should be %d\n", (int) aval, 49); } MPI_Type_free( &inttype ); MPI_Type_free( &eviltype ); return errs; } int vector_blklen_stride_of_int_with_lb_ub_test(void) { int err, errs = 0, val; MPI_Aint lb, extent, aval, true_lb; int blocks[3] = { 1, 4, 1 }; MPI_Aint disps[3] = { -3, 0, 6 }; MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB }; char *typemapstring = 0; MPI_Datatype inttype, eviltype; /* build same type as in int_with_lb_ub_test() */ typemapstring = (char*)"{ (LB,-3),4*(BYTE,0),(UB,6) }"; err = MPI_Type_struct(3, blocks, disps, types, &inttype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_struct of %s failed.\n", typemapstring ); if (verbose) MTestPrintError( err ); /* No point in continuing */ return errs; } err = MPI_Type_vector(3, 4, 5, inttype, &eviltype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_vector failed.\n"); if (verbose) MTestPrintError( err ); /* no point in continuing */ return errs; } err = MPI_Type_size(eviltype, &val); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_size failed.\n"); if (verbose) MTestPrintError( err ); } if (val != 48) { errs++; if (verbose) fprintf(stderr, " size of type = %d; should be %d\n", val, 48); } err = MPI_Type_extent(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 126) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) aval, 126); } err = MPI_Type_lb(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_lb failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -3) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -3); } err = MPI_Type_get_extent(eviltype, &lb, &extent); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (lb != -3) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -3); } if (extent != 126) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) extent, 126); } err = MPI_Type_ub(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_ub failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 123) { errs++; if (verbose) fprintf(stderr, " ub of type = %d; should be %d\n", (int) aval, 123); } err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_true_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (true_lb != 0) { errs++; if (verbose) fprintf(stderr, " true_lb of type = %d; should be %d\n", (int) true_lb, 0); } if (aval != 121) { errs++; if (verbose) fprintf(stderr, " true extent of type = %d; should be %d\n", (int) aval, 121); } MPI_Type_free( &inttype ); MPI_Type_free( &eviltype ); return errs; } int vector_blklen_negstride_of_int_with_lb_ub_test(void) { int err, errs = 0, val; MPI_Aint lb, extent, aval, true_lb; int blocks[3] = { 1, 4, 1 }; MPI_Aint disps[3] = { -3, 0, 6 }; MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB }; MPI_Datatype inttype, eviltype; /* build same type as in int_with_lb_ub_test() */ err = MPI_Type_struct(3, blocks, disps, types, &inttype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_struct failed.\n"); if (verbose) MTestPrintError( err ); /* no point in continuing */ return errs; } err = MPI_Type_vector(3, 4, -5, inttype, &eviltype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_vector failed.\n"); if (verbose) MTestPrintError( err ); /* no point in continuing */ return errs; } err = MPI_Type_size(eviltype, &val); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_size failed.\n"); if (verbose) MTestPrintError( err ); } if (val != 48) { errs++; if (verbose) fprintf(stderr, " size of type = %d; should be %d\n", val, 48); } err = MPI_Type_extent(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 126) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) aval, 126); } err = MPI_Type_lb(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_lb failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -93) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -93); } err = MPI_Type_get_extent(eviltype, &lb, &extent); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (lb != -93) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -93); } if (extent != 126) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) extent, 126); } err = MPI_Type_ub(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_ub failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 33) { errs++; if (verbose) fprintf(stderr, " ub of type = %d; should be %d\n", (int) aval, 33); } err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_true_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (true_lb != -90) { errs++; if (verbose) fprintf(stderr, " true_lb of type = %d; should be %d\n", (int) true_lb, -90); } if (aval != 121) { errs++; if (verbose) fprintf(stderr, " true extent of type = %d; should be %d\n", (int) aval, 121); } MPI_Type_free( &inttype ); MPI_Type_free( &eviltype ); return errs; } int int_with_negextent_test(void) { int err, errs = 0, val; MPI_Aint lb, extent, aval, true_lb; int blocks[3] = { 1, 4, 1 }; MPI_Aint disps[3] = { 6, 0, -3 }; MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB }; char *typemapstring =0; MPI_Datatype eviltype; typemapstring = (char*)"{ (LB,6),4*(BYTE,0),(UB,-3) }"; err = MPI_Type_struct(3, blocks, disps, types, &eviltype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_struct of %s failed.\n", typemapstring ); if (verbose) MTestPrintError( err ); /* No point in contiuing */ return errs; } err = MPI_Type_size(eviltype, &val); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_size failed.\n"); if (verbose) MTestPrintError( err ); } if (val != 4) { errs++; if (verbose) fprintf(stderr, " size of type = %d; should be %d\n", val, 4); } err = MPI_Type_extent(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -9) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) aval, -9); } err = MPI_Type_lb(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_lb failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 6) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, 6); } err = MPI_Type_get_extent(eviltype, &lb, &extent); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (lb != 6) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, 6); } if (extent != -9) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) extent, -9); } err = MPI_Type_ub(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_ub failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -3) { errs++; if (verbose) fprintf(stderr, " ub of type = %d; should be %d\n", (int) aval, -3); } err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_true_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (true_lb != 0) { errs++; if (verbose) fprintf(stderr, " true_lb of type = %d; should be %d\n", (int) true_lb, 0); } if (aval != 4) { errs++; if (verbose) fprintf(stderr, " true extent of type = %d; should be %d\n", (int) aval, 4); } MPI_Type_free(&eviltype); return errs; } int vector_blklen_stride_negextent_of_int_with_lb_ub_test(void) { int err, errs = 0, val; MPI_Aint lb, extent, true_lb, aval; int blocks[3] = { 1, 4, 1 }; MPI_Aint disps[3] = { 6, 0, -3 }; MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB }; MPI_Datatype inttype, eviltype; char *typemapstring = 0; /* build same type as in int_with_lb_ub_test() */ typemapstring = (char*)"{ (LB,6),4*(BYTE,0),(UB,-3) }"; err = MPI_Type_struct(3, blocks, disps, types, &inttype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_struct of %s failed.\n", typemapstring ); if (verbose) MTestPrintError( err ); /* No point in continuing */ return errs; } err = MPI_Type_vector(3, 4, 5, inttype, &eviltype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_vector failed.\n"); if (verbose) MTestPrintError( err ); /* no point in continuing */ return errs; } err = MPI_Type_size(eviltype, &val); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_size failed.\n"); if (verbose) MTestPrintError( err ); } if (val != 48) { errs++; if (verbose) fprintf(stderr, " size of type = %d; should be %d\n", val, 48); } err = MPI_Type_extent(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 108) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) aval, 108); } err = MPI_Type_lb(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_lb failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -111) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -111); } err = MPI_Type_get_extent(eviltype, &lb, &extent); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (lb != -111) { errs++; if (verbose) fprintf(stderr, " lb of type = %d; should be %d\n", (int) aval, -111); } if (extent != 108) { errs++; if (verbose) fprintf(stderr, " extent of type = %d; should be %d\n", (int) extent, 108); } err = MPI_Type_ub(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_ub failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -3) { errs++; if (verbose) fprintf(stderr, " ub of type = %d; should be %d\n", (int) aval, -3); } err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_true_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (true_lb != -117) { errs++; if (verbose) fprintf(stderr, " true_lb of type = %d; should be %d\n", (int) true_lb, -117); } if (aval != 121) { errs++; if (verbose) fprintf(stderr, " true extent of type = %d; should be %d\n", (int) aval, 121); } MPI_Type_free( &inttype ); MPI_Type_free( &eviltype ); return errs; } int vector_blklen_negstride_negextent_of_int_with_lb_ub_test(void) { int err, errs = 0, val; MPI_Aint extent, lb, aval, true_lb; int blocks[3] = { 1, 4, 1 }; MPI_Aint disps[3] = { 6, 0, -3 }; MPI_Datatype types[3] = { MPI_LB, MPI_BYTE, MPI_UB }; MPI_Datatype inttype, eviltype; /* build same type as in int_with_lb_ub_test() */ err = MPI_Type_struct(3, blocks, disps, types, &inttype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_struct failed.\n"); if (verbose) MTestPrintError( err ); /* no point in continuing */ return errs; } err = MPI_Type_vector(3, 4, -5, inttype, &eviltype); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_vector failed.\n"); if (verbose) MTestPrintError( err ); /* no point in continuing */ return errs; } err = MPI_Type_size(eviltype, &val); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_size failed.\n"); if (verbose) MTestPrintError( err ); } if (val != 48) { errs++; if (verbose) fprintf(stderr, " size of type = %d; should be %d\n", val, 48); } err = MPI_Type_extent(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 108) { errs++; if (verbose) fprintf(stderr, " extent of type = %ld; should be %d\n", (long) aval, 108); } err = MPI_Type_lb(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_lb failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != -21) { errs++; if (verbose) fprintf(stderr, " lb of type = %ld; should be %d\n", (long) aval, -21); } err = MPI_Type_get_extent(eviltype, &lb, &extent); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (lb != -21) { errs++; if (verbose) fprintf(stderr, " lb of type = %ld; should be %d\n", (long) aval, -21); } if (extent != 108) { errs++; if (verbose) fprintf(stderr, " extent of type = %ld; should be %d\n", (long) extent, 108); } err = MPI_Type_ub(eviltype, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_ub failed.\n"); if (verbose) MTestPrintError( err ); } if (aval != 87) { errs++; if (verbose) fprintf(stderr, " ub of type = %ld; should be %d\n", (long) aval, 87); } err = MPI_Type_get_true_extent(eviltype, &true_lb, &aval); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, " MPI_Type_get_true_extent failed.\n"); if (verbose) MTestPrintError( err ); } if (true_lb != -27) { errs++; if (verbose) fprintf(stderr, " true_lb of type = %ld; should be %d\n", (long) true_lb, -27); } if (aval != 121) { errs++; if (verbose) fprintf(stderr, " true extent of type = %ld; should be %d\n", (long) aval, 121); } MPI_Type_free( &inttype ); MPI_Type_free( &eviltype ); return errs; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/struct-derived-zeros.c000644 001750 001750 00000002607 12342443662 025247 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* Based on code from Jeff Parker at IBM. */ #include #include #include "mpitest.h" int main(int argc, char *argv[]) { MPI_Datatype mystruct, vecs[3]; MPI_Aint stride = 5, displs[3]; int i=0, blockcount[3]; int errs=0; MTest_Init( &argc, &argv ); for(i = 0; i < 3; i++) { MPI_Type_hvector(i, 1, stride, MPI_INT, &vecs[i]); MPI_Type_commit(&vecs[i]); blockcount[i]=1; } displs[0]=0; displs[1]=-100; displs[2]=-200; /* irrelevant */ MPI_Type_struct(3, blockcount, displs, vecs, &mystruct); MPI_Type_commit(&mystruct); MPI_Type_free(&mystruct); for(i = 0; i < 3; i++) { MPI_Type_free(&vecs[i]); } /* this time with the first argument always 0 */ for(i = 0; i < 3; i++) { MPI_Type_hvector(0, 1, stride, MPI_INT, &vecs[i]); MPI_Type_commit(&vecs[i]); blockcount[i]=1; } displs[0]=0; displs[1]=-100; displs[2]=-200; /* irrelevant */ MPI_Type_struct(3, blockcount, displs, vecs, &mystruct); MPI_Type_commit(&mystruct); MPI_Type_free(&mystruct); for(i = 0; i < 3; i++) { MPI_Type_free(&vecs[i]); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/simple-pack-external.c000644 001750 001750 00000022003 12342443662 025160 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include #include #include "mpitest.h" static int verbose = 0; /* tests */ int builtin_float_test(void); int vector_of_vectors_test(void); int optimizable_vector_of_basics_test(void); int struct_of_basics_test(void); /* helper functions */ int parse_args(int argc, char **argv); int main(int argc, char **argv) { int err, errs = 0; MTest_Init(&argc, &argv); parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = builtin_float_test(); if (err && verbose) fprintf(stderr, "%d errors in builtin float test.\n", err); errs += err; err = vector_of_vectors_test(); if (err && verbose) fprintf(stderr, "%d errors in vector of vectors test.\n", err); errs += err; err = optimizable_vector_of_basics_test(); if (err && verbose) fprintf(stderr, "%d errors in vector of basics test.\n", err); errs += err; err = struct_of_basics_test(); if (err && verbose) fprintf(stderr, "%d errors in struct of basics test.\n", err); errs += err; MTest_Finalize( errs ); MPI_Finalize(); return 0; } /* builtin_float_test() * * Tests functionality of get_envelope() and get_contents() on a MPI_FLOAT. * * Returns the number of errors encountered. */ int builtin_float_test(void) { int nints, nadds, ntypes, combiner; int /* err, */ errs = 0; /* err = */ MPI_Type_get_envelope(MPI_FLOAT, &nints, &nadds, &ntypes, &combiner); if (combiner != MPI_COMBINER_NAMED) errs++; /* Note: it is erroneous to call MPI_Type_get_contents() on a basic. */ return errs; } /* vector_of_vectors_test() * * Builds a vector of a vector of ints. Assuming an int array of size 9 * integers, and treating the array as a 3x3 2D array, this will grab the * corners. * * Returns the number of errors encountered. */ int vector_of_vectors_test(void) { MPI_Datatype inner_vector; MPI_Datatype outer_vector; int array[9] = { 1, -1, 2, -2, -3, -4, 3, -5, 4 }; char *buf; int i, err, errs = 0; MPI_Aint sizeoftype, position; /* set up type */ err = MPI_Type_vector(2, 1, 2, MPI_INT, &inner_vector); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, "error in MPI call; aborting after %d errors\n", errs+1); return errs; } err = MPI_Type_vector(2, 1, 2, inner_vector, &outer_vector); if (err != MPI_SUCCESS) { errs++; if (verbose) fprintf(stderr, "error in MPI call; aborting after %d errors\n", errs+1); return errs; } MPI_Type_commit(&outer_vector); MPI_Pack_external_size((char*)"external32", 1, outer_vector, &sizeoftype); if (sizeoftype != 4*4) { errs++; if (verbose) fprintf(stderr, "size of type = %d; should be %d\n", (int) sizeoftype, 4*4); return errs; } buf = (char *) malloc(sizeoftype); position = 0; err = MPI_Pack_external((char*)"external32", array, 1, outer_vector, buf, sizeoftype, &position); if (position != sizeoftype) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (pack)\n", (int) position, (int) sizeoftype); } memset(array, 0, 9*sizeof(int)); position = 0; err = MPI_Unpack_external((char*)"external32", buf, sizeoftype, &position, array, 1, outer_vector); if (position != sizeoftype) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (unpack)\n", (int) position, (int) sizeoftype); } for (i=0; i < 9; i++) { int goodval; switch (i) { case 0: goodval = 1; break; case 2: goodval = 2; break; case 6: goodval = 3; break; case 8: goodval = 4; break; default: goodval = 0; break; } if (array[i] != goodval) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], goodval); } } MPI_Type_free(&inner_vector); MPI_Type_free(&outer_vector); return errs; } /* optimizable_vector_of_basics_test() * * Builds a vector of ints. Count is 10, blocksize is 2, stride is 2, so this * is equivalent to a contig of 20. * * Returns the number of errors encountered. */ int optimizable_vector_of_basics_test(void) { MPI_Datatype parent_type; int array[20] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }; char *buf; int i; MPI_Aint sizeofint, sizeoftype, position; int /* err, */ errs = 0; MPI_Pack_external_size((char*)"external32", 1, MPI_INT, &sizeofint); if (sizeofint != 4) { errs++; if (verbose) fprintf(stderr, "size of external32 MPI_INT = %d; should be %d\n", (int) sizeofint, 4); } /* set up type */ /* err = */ MPI_Type_vector(10, 2, 2, MPI_INT, &parent_type); MPI_Type_commit(&parent_type); MPI_Pack_external_size((char*)"external32", 1, parent_type, &sizeoftype); if (sizeoftype != 20 * sizeofint) { errs++; if (verbose) fprintf(stderr, "size of vector = %d; should be %d\n", (int) sizeoftype, (int) (20 * sizeofint)); } buf = (char *) malloc(sizeoftype); position = 0; /* err = */ MPI_Pack_external((char*)"external32", array, 1, parent_type, buf, sizeoftype, &position); if (position != sizeoftype) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (pack)\n", (int) position, (int) sizeoftype); } memset(array, 0, 20 * sizeof(int)); position = 0; /* err = */ MPI_Unpack_external((char*)"external32", buf, sizeoftype, &position, array, 1, parent_type); if (position != sizeoftype) { errs++; if (verbose) fprintf(stderr, "position = %ld; should be %ld (unpack)\n", (long) position, (long) sizeoftype); } for (i=0; i < 20; i++) { if (array[i] != i) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], i); } } MPI_Type_free(&parent_type); return errs; } /* struct_of_basics_test() * * Builds a struct of ints. Count is 10, all blocksizes are 2, all * strides are 2*sizeofint, so this is equivalent to a contig of 20. * * Returns the number of errors encountered. */ int struct_of_basics_test(void) { MPI_Datatype parent_type; int array[20] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }; char *buf; int i; MPI_Aint sizeofint, sizeoftype, position; int blocks[10]; MPI_Aint indices[10]; MPI_Datatype types[10]; int /* err, */ errs = 0; MPI_Pack_external_size((char*)"external32", 1, MPI_INT, &sizeofint); if (sizeofint != 4) { errs++; if (verbose) fprintf(stderr, "size of external32 MPI_INT = %d; should be %d\n", (int) sizeofint, 4); } for (i = 0; i < 10; i++) { blocks[i] = 2; indices[i] = 2 * i * sizeofint; /* This will cause MPICH to consider this as a blockindex. We * need different types here. */ types[i] = MPI_INT; } /* set up type */ /* err = */ MPI_Type_struct(10, blocks, indices, types, &parent_type); MPI_Type_commit(&parent_type); MPI_Pack_external_size((char*)"external32", 1, parent_type, &sizeoftype); if (sizeoftype != 20 * sizeofint) { errs++; if (verbose) fprintf(stderr, "size of vector = %d; should be %d\n", (int) sizeoftype, (int) (20 * sizeofint)); } buf = (char *) malloc(sizeoftype); position = 0; /* err = */ MPI_Pack_external((char*)"external32", array, 1, parent_type, buf, sizeoftype, &position); if (position != sizeoftype) { errs++; if (verbose) fprintf(stderr, "position = %d; should be %d (pack)\n", (int) position, (int) sizeoftype); } memset(array, 0, 20 * sizeof(int)); position = 0; /* err = */ MPI_Unpack_external((char*)"external32", buf, sizeoftype, &position, array, 1, parent_type); if (position != sizeoftype) { errs++; if (verbose) fprintf(stderr, "position = %ld; should be %ld (unpack)\n", (long) position, (long) sizeoftype); } for (i=0; i < 20; i++) { if (array[i] != i) { errs++; if (verbose) fprintf(stderr, "array[%d] = %d; should be %d\n", i, array[i], i); } } MPI_Type_free(&parent_type); return errs; } int parse_args(int argc, char **argv) { int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/simple-resized.c000644 001750 001750 00000005540 12342443662 024076 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif static int verbose = 0; /* tests */ int derived_resized_test(void); /* helper functions */ int parse_args(int argc, char **argv); int main(int argc, char **argv) { int err, errs = 0; MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */ parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* perform some tests */ err = derived_resized_test(); if (err && verbose) fprintf(stderr, "%d errors in derived_resized test.\n", err); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } /* derived_resized_test() * * Tests behavior with resizing of a simple derived type. * * Returns the number of errors encountered. */ int derived_resized_test(void) { int err, errs = 0; int count = 2; MPI_Datatype newtype, resizedtype; int size; MPI_Aint extent; err = MPI_Type_contiguous(count, MPI_INT, &newtype); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error creating type in derived_resized_test()\n"); } errs++; } err = MPI_Type_create_resized(newtype, (MPI_Aint) 0, (MPI_Aint) (2*sizeof(int) + 10), &resizedtype); err = MPI_Type_size(resizedtype, &size); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type size in derived_resized_test()\n"); } errs++; } if (size != 2*sizeof(int)) { if (verbose) { fprintf(stderr, "error: size != %d in derived_resized_test()\n", (int) (2*sizeof(int))); } errs++; } err = MPI_Type_extent(resizedtype, &extent); if (err != MPI_SUCCESS) { if (verbose) { fprintf(stderr, "error obtaining type extent in derived_resized_test()\n"); } errs++; } if (extent != 2*sizeof(int) + 10) { if (verbose) { fprintf(stderr, "error: invalid extent (%d) in derived_resized_test(); should be %d\n", (int) extent, (int) (2*sizeof(int) + 10)); } errs++; } MPI_Type_free( &newtype ); MPI_Type_free( &resizedtype ); return errs; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/tresized.c000644 001750 001750 00000003427 12342443662 022775 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test of type resized"; */ int main( int argc, char *argv[] ) { int errs = 0, i; int rank, size, source, dest; int count; int *buf; MPI_Comm comm; MPI_Status status; MPI_Datatype newtype; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); source = 0; dest = size - 1; MPI_Type_create_resized( MPI_INT, 0, 3 * sizeof(int), &newtype ); MPI_Type_commit( &newtype ); for (count = 1; count < 65000; count = count * 2) { buf = (int *)malloc( count * 3 * sizeof(int) ); if (!buf) { MPI_Abort( comm, 1 ); exit(1); } for (i=0; i<3*count; i++) buf[i] = -1; if (rank == source) { for (i=0; i #include int main(int argc, char* argv[]) { int iam, np; int m = 2, n = 0, lda = 1; double A[2]; MPI_Comm comm = MPI_COMM_WORLD; MPI_Datatype type = MPI_DOUBLE, vtype; MPI_Init(&argc,&argv); MPI_Comm_size(comm, &np); MPI_Comm_rank(comm, &iam); if (np < 2) { printf( "Should be at least 2 processes for the test\n"); } else { MPI_Type_vector(n, m, lda, type, &vtype); MPI_Type_commit(&vtype); A[0] = -1.0-0.1*iam; A[1] = 0.5+0.1*iam; printf("In process %i of %i before Bcast: A = %f,%f\n", iam, np, A[0], A[1] ); MPI_Bcast(A, 1, vtype, 0, comm); printf("In process %i of %i after Bcast: A = %f,%f\n", iam, np, A[0], A[1]); MPI_Type_free(&vtype); } MPI_Finalize(); return(0); } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/tmatchsize.c000644 001750 001750 00000010255 12342443662 023314 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test of type_match_size"; */ /* * type match size is part of the extended Fortran support, and may not * be present in */ int main( int argc, char *argv[] ) { int errs = 0, err; int dsize; MPI_Datatype newtype; MTest_Init( &argc, &argv ); /* Check the most likely cases. Note that it is an error to free the type returned by MPI_Type_match_size. Also note that it is an error to request a size not supported by the compiler, so Type_match_size should generate an error in that case */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); err = MPI_Type_match_size( MPI_TYPECLASS_REAL, sizeof(float), &newtype ); if (err) { errs++; MTestPrintErrorMsg( "Float: ", err ); } else { err = MPI_Type_size( newtype, &dsize ); if (err) { errs++; MTestPrintErrorMsg( "Float type: ", err ); } else { if (dsize != sizeof(float)) { errs++; printf( "Unexpected size for float (%d != %d)\n", dsize, (int) sizeof(float) ); } } } err = MPI_Type_match_size( MPI_TYPECLASS_REAL, sizeof(double), &newtype ); if (err) { errs++; MTestPrintErrorMsg( "Double: ", err ); } else { MPI_Type_size( newtype, &dsize ); if (dsize != sizeof(double)) { errs++; printf( "Unexpected size for double\n" ); } } #ifdef HAVE_LONG_DOUBLE err = MPI_Type_match_size( MPI_TYPECLASS_REAL, sizeof(long double), &newtype ); if (err) { errs++; MTestPrintErrorMsg( "Long double: ", err ); } else { MPI_Type_size( newtype, &dsize ); if (dsize != sizeof(long double)) { errs++; printf( "Unexpected size for long double\n" ); } } #endif err = MPI_Type_match_size( MPI_TYPECLASS_INTEGER, sizeof(short), &newtype ); if (err) { errs++; MTestPrintErrorMsg( "Short: ", err ); } else { MPI_Type_size( newtype, &dsize ); if (dsize != sizeof(short)) { errs++; printf( "Unexpected size for short\n" ); } } err = MPI_Type_match_size( MPI_TYPECLASS_INTEGER, sizeof(int), &newtype ); if (err) { errs++; MTestPrintErrorMsg( "Int: ", err ); } else { MPI_Type_size( newtype, &dsize ); if (dsize != sizeof(int)) { errs++; printf( "Unexpected size for int\n" ); } } err = MPI_Type_match_size( MPI_TYPECLASS_INTEGER, sizeof(long), &newtype ); if (err) { errs++; MTestPrintErrorMsg( "Long: ", err ); } else { MPI_Type_size( newtype, &dsize ); if (dsize != sizeof(long)) { errs++; printf( "Unexpected size for long\n" ); } } #ifdef HAVE_LONG_LONG err = MPI_Type_match_size( MPI_TYPECLASS_INTEGER, sizeof(long long), &newtype ); if (err) { errs++; MTestPrintErrorMsg( "Long long: ", err ); } else { MPI_Type_size( newtype, &dsize ); if (dsize != sizeof(long long)) { errs++; printf( "Unexpected size for long long\n" ); } } #endif /* COMPLEX is a FORTRAN type. The MPICH Type_match_size attempts to give a valid datatype, but if Fortran is not available, MPI_COMPLEX and MPI_DOUBLE_COMPLEX are not supported. Allow this case by testing for MPI_DATATYPE_NULL */ if (MPI_COMPLEX != MPI_DATATYPE_NULL) { err = MPI_Type_match_size( MPI_TYPECLASS_COMPLEX, 2*sizeof(float), &newtype ); if (err) { errs++; MTestPrintErrorMsg( "Complex: ", err ); } else { MPI_Type_size( newtype, &dsize ); if (dsize != 2*sizeof(float)) { errs++; printf( "Unexpected size for complex\n" ); } } } if (MPI_COMPLEX != MPI_DATATYPE_NULL && MPI_DOUBLE_COMPLEX != MPI_DATATYPE_NULL) { err = MPI_Type_match_size( MPI_TYPECLASS_COMPLEX, 2*sizeof(double), &newtype ); if (err) { errs++; MTestPrintErrorMsg( "Double complex: ", err ); } else { MPI_Type_size( newtype, &dsize ); if (dsize != 2*sizeof(double)) { errs++; printf( "Unexpected size for double complex\n" ); } } } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/unusual-noncontigs.c000644 001750 001750 00000042073 12342443662 025017 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include #include #include #include "mpi.h" /* The default behavior of the test routines should be to briefly indicate the cause of any errors - in this test, that means that verbose needs to be set. Verbose should turn on output that is independent of error levels. */ static int verbose = 1; int parse_args(int argc, char **argv); int struct_negdisp_test(void); int vector_negstride_test(void); int indexed_negdisp_test(void); int struct_struct_test(void); int flatten_test(void); int build_array_section_type(MPI_Aint aext, MPI_Aint astart, MPI_Aint aend, MPI_Datatype *datatype); int main(int argc, char *argv[]) { int err, errs = 0; /* Initialize MPI */ MPI_Init(&argc, &argv); parse_args(argc, argv); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); err = struct_negdisp_test(); if (verbose && err) fprintf(stderr, "error in struct_negdisp_test\n"); errs += err; err = vector_negstride_test(); if (verbose && err) fprintf(stderr, "error in vector_negstride_test\n"); errs += err; err = indexed_negdisp_test(); if (verbose && err) fprintf(stderr, "error in indexed_negdisp_test\n"); errs += err; err = struct_struct_test(); if (verbose && err) fprintf(stderr, "error in struct_struct_test\n"); errs += err; err = flatten_test(); if (verbose && err) fprintf(stderr, "error in flatten_test\n"); errs += err; /* print message and exit */ if (errs) { fprintf(stderr, "Found %d errors\n", errs); } else { printf(" No Errors\n"); } MPI_Finalize(); return 0; } /* test uses a struct type that describes data that is contiguous, * but processed in a noncontiguous way. */ int struct_negdisp_test(void) { int err, errs = 0; int sendbuf[6] = { 1, 2, 3, 4, 5, 6 }; int recvbuf[6] = { -1, -2, -3, -4, -5, -6 }; MPI_Datatype mystruct; MPI_Request request; MPI_Status status; MPI_Aint disps[2] = { 0, -1*((int) sizeof(int)) }; int blks[2] = { 1, 1, }; MPI_Datatype types[2] = { MPI_INT, MPI_INT }; err = MPI_Type_struct(2, blks, disps, types, &mystruct); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Type_struct returned error\n"); } } MPI_Type_commit(&mystruct); err = MPI_Irecv(recvbuf+1, 4, MPI_INT, 0, 0, MPI_COMM_SELF, &request); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Irecv returned error\n"); } } err = MPI_Send(sendbuf+2, 2, mystruct, 0, 0, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Send returned error\n"); } } err = MPI_Wait(&request, &status); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Wait returned error\n"); } } /* verify data */ if (recvbuf[0] != -1) { errs++; if (verbose) { fprintf(stderr, "recvbuf[0] = %d; should be %d\n", recvbuf[0], -1); } } if (recvbuf[1] != 3) { errs++; if (verbose) { fprintf(stderr, "recvbuf[1] = %d; should be %d\n", recvbuf[1], 3); } } if (recvbuf[2] != 2) { errs++; if (verbose) { fprintf(stderr, "recvbuf[2] = %d; should be %d\n", recvbuf[2], 2); } } if (recvbuf[3] != 5) { errs++; if (verbose) { fprintf(stderr, "recvbuf[3] = %d; should be %d\n", recvbuf[3], 5); } } if (recvbuf[4] != 4) { errs++; if (verbose) { fprintf(stderr, "recvbuf[4] = %d; should be %d\n", recvbuf[4], 4); } } if (recvbuf[5] != -6) { errs++; if (verbose) { fprintf(stderr, "recvbuf[5] = %d; should be %d\n", recvbuf[5], -6); } } MPI_Type_free(&mystruct); return errs; } /* test uses a vector type that describes data that is contiguous, * but processed in a noncontiguous way. this is effectively the * same type as in the struct_negdisp_test above. */ int vector_negstride_test(void) { int err, errs = 0; int sendbuf[6] = { 1, 2, 3, 4, 5, 6 }; int recvbuf[6] = { -1, -2, -3, -4, -5, -6 }; MPI_Datatype myvector; MPI_Request request; MPI_Status status; err = MPI_Type_vector(2, 1, -1, MPI_INT, &myvector); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Type_vector returned error\n"); } } MPI_Type_commit(&myvector); err = MPI_Irecv(recvbuf+1, 4, MPI_INT, 0, 0, MPI_COMM_SELF, &request); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Irecv returned error\n"); } } err = MPI_Send(sendbuf+2, 2, myvector, 0, 0, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Send returned error\n"); } } err = MPI_Wait(&request, &status); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Wait returned error\n"); } } /* verify data */ if (recvbuf[0] != -1) { errs++; if (verbose) { fprintf(stderr, "recvbuf[0] = %d; should be %d\n", recvbuf[0], -1); } } if (recvbuf[1] != 3) { errs++; if (verbose) { fprintf(stderr, "recvbuf[1] = %d; should be %d\n", recvbuf[1], 3); } } if (recvbuf[2] != 2) { errs++; if (verbose) { fprintf(stderr, "recvbuf[2] = %d; should be %d\n", recvbuf[2], 2); } } if (recvbuf[3] != 5) { errs++; if (verbose) { fprintf(stderr, "recvbuf[3] = %d; should be %d\n", recvbuf[3], 5); } } if (recvbuf[4] != 4) { errs++; if (verbose) { fprintf(stderr, "recvbuf[4] = %d; should be %d\n", recvbuf[4], 4); } } if (recvbuf[5] != -6) { errs++; if (verbose) { fprintf(stderr, "recvbuf[5] = %d; should be %d\n", recvbuf[5], -6); } } MPI_Type_free(&myvector); return errs; } /* test uses a indexed type that describes data that is contiguous, * but processed in a noncontiguous way. this is effectively the same * type as in the two tests above. */ int indexed_negdisp_test(void) { int err, errs = 0; int sendbuf[6] = { 1, 2, 3, 4, 5, 6 }; int recvbuf[6] = { -1, -2, -3, -4, -5, -6 }; MPI_Datatype myindexed; MPI_Request request; MPI_Status status; int disps[2] = { 0, -1 }; int blks[2] = { 1, 1 }; err = MPI_Type_indexed(2, blks, disps, MPI_INT, &myindexed); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Type_indexed returned error\n"); } } MPI_Type_commit(&myindexed); err = MPI_Irecv(recvbuf+1, 4, MPI_INT, 0, 0, MPI_COMM_SELF, &request); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Irecv returned error\n"); } } err = MPI_Send(sendbuf+2, 2, myindexed, 0, 0, MPI_COMM_SELF); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Send returned error\n"); } } err = MPI_Wait(&request, &status); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Wait returned error\n"); } } /* verify data */ if (recvbuf[0] != -1) { errs++; if (verbose) { fprintf(stderr, "recvbuf[0] = %d; should be %d\n", recvbuf[0], -1); } } if (recvbuf[1] != 3) { errs++; if (verbose) { fprintf(stderr, "recvbuf[1] = %d; should be %d\n", recvbuf[1], 3); } } if (recvbuf[2] != 2) { errs++; if (verbose) { fprintf(stderr, "recvbuf[2] = %d; should be %d\n", recvbuf[2], 2); } } if (recvbuf[3] != 5) { errs++; if (verbose) { fprintf(stderr, "recvbuf[3] = %d; should be %d\n", recvbuf[3], 5); } } if (recvbuf[4] != 4) { errs++; if (verbose) { fprintf(stderr, "recvbuf[4] = %d; should be %d\n", recvbuf[4], 4); } } if (recvbuf[5] != -6) { errs++; if (verbose) { fprintf(stderr, "recvbuf[5] = %d; should be %d\n", recvbuf[5], -6); } } MPI_Type_free(&myindexed); return errs; } #define check_err(fn_name_) \ do { \ if (err != MPI_SUCCESS) { \ errs++; \ if (verbose) { \ int len_; \ char err_str_[MPI_MAX_ERROR_STRING]; \ MPI_Error_string(err, err_str_, &len_); \ fprintf(stderr, #fn_name_ " failed at line %d, err=%d: %s\n", \ __LINE__, err, err_str_); \ } \ } \ } while (0) /* test case from tt#1030 ported to C * * Thanks to Matthias Lieber for reporting the bug and providing a good test * program. */ int struct_struct_test(void) { int err, errs = 0; int i, j, dt_size = 0; MPI_Request req[2]; #define COUNT (2) MPI_Aint displ[COUNT]; int blens[COUNT]; MPI_Datatype types[COUNT]; MPI_Datatype datatype; /* A slight difference from the F90 test: F90 arrays are column-major, C * arrays are row-major. So we invert the order of dimensions. */ #define N (2) #define M (4) int array[N][M] = { {-1, -1, -1, -1}, {-1, -1, -1, -1} }; int expected[N][M] = { {-1, 1, 2, 5}, {-1, 3, 4, 6} }; int seq_array[N*M]; MPI_Aint astart, aend; MPI_Aint size_exp = 0; /* 1st section selects elements 1 and 2 out of 2nd dimension, complete 1st dim. * should receive the values 1, 2, 3, 4 */ astart = 1; aend = 2; err = build_array_section_type(M, astart, aend, &types[0]); if (err) { errs++; if (verbose) fprintf(stderr, "build_array_section_type failed\n"); return errs; } blens[0] = N; displ[0] = 0; size_exp = size_exp + N * (aend-astart+1) * sizeof(int); /* 2nd section selects last element of 2nd dimension, complete 1st dim. * should receive the values 5, 6 */ astart = 3; aend = 3; err = build_array_section_type(M, astart, aend, &types[1]); if (err) { errs++; if (verbose) fprintf(stderr, "build_array_section_type failed\n"); return errs; } blens[1] = N; displ[1] = 0; size_exp = size_exp + N * (aend-astart+1) * sizeof(int); /* create type */ err = MPI_Type_create_struct(COUNT, blens, displ, types, &datatype); check_err(MPI_Type_create_struct); err = MPI_Type_commit(&datatype); check_err(MPI_Type_commit); err = MPI_Type_size(datatype, &dt_size); check_err(MPI_Type_size); if (dt_size != size_exp) { errs++; if (verbose) fprintf(stderr, "unexpected type size\n"); } /* send the type to ourselves to make sure that the type describes data correctly */ for (i = 0; i < (N*M) ; ++i) seq_array[i] = i + 1; /* source values 1..(N*M) */ err = MPI_Isend(&seq_array[0], dt_size/sizeof(int), MPI_INT, 0, 42, MPI_COMM_SELF, &req[0]); check_err(MPI_Isend); err = MPI_Irecv(&array[0][0], 1, datatype, 0, 42, MPI_COMM_SELF, &req[1]); check_err(MPI_Irecv); err = MPI_Waitall(2, req, MPI_STATUSES_IGNORE); check_err(MPI_Waitall); /* check against expected */ for (i = 0; i < N; ++i) { for (j = 0; j < M; ++j) { if (array[i][j] != expected[i][j]) { errs++; if (verbose) fprintf(stderr, "array[%d][%d]=%d, should be %d\n", i, j, array[i][j], expected[i][j]); } } } err = MPI_Type_free(&datatype); check_err(MPI_Type_free); err = MPI_Type_free(&types[0]); check_err(MPI_Type_free); err = MPI_Type_free(&types[1]); check_err(MPI_Type_free); return errs; #undef M #undef N #undef COUNT } /* create a datatype for a 1D int array subsection - a subsection of the first dimension is defined via astart, aend - indexes are assumed to start with 0, that means: - 0 <= astart <= aend < aext - astart and aend are inclusive example: aext = 8, astart=2, aend=4 would produce: index | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 1D array ############################### datatype LB ########### UB */ int build_array_section_type(MPI_Aint aext, MPI_Aint astart, MPI_Aint aend, MPI_Datatype *datatype) { #define COUNT (3) int err, errs = 0; MPI_Aint displ[COUNT]; int blens[COUNT]; MPI_Datatype types[COUNT]; *datatype = MPI_DATATYPE_NULL; /* lower bound marker */ types[0] = MPI_LB; displ[0] = 0; blens[0] = 1; /* subsection starting at astart */ displ[1] = astart * sizeof(int); types[1] = MPI_INT; blens[1] = aend - astart + 1; /* upper bound marker */ types[2] = MPI_UB; displ[2] = aext * sizeof(int); blens[2] = 1; err = MPI_Type_create_struct(COUNT, blens, displ, types, datatype); if (err != MPI_SUCCESS) { errs++; if (verbose) { fprintf(stderr, "MPI_Type_create_struct failed, err=%d\n", err); } } return errs; #undef COUNT } /* start_idx is the "zero" point for the unpack */ static int pack_and_check_expected(MPI_Datatype type, const char *name, int start_idx, int size, int *array, int *expected) { int i; int err, errs = 0; int pack_size = -1; int *pack_buf = NULL; int pos; int type_size = -1; int sendbuf[8] = {0,1,2,3,4,5,6,7}; err = MPI_Type_size(type, &type_size); check_err(MPI_Type_size); assert(sizeof(sendbuf) >= type_size); err = MPI_Pack_size(type_size/sizeof(int), MPI_INT, MPI_COMM_SELF, &pack_size); check_err(MPI_Pack_size); pack_buf = malloc(pack_size); assert(pack_buf!=NULL); pos = 0; err = MPI_Pack(&sendbuf[0], type_size/sizeof(int), MPI_INT, pack_buf, pack_size, &pos, MPI_COMM_SELF); check_err(MPI_Pack); pos = 0; err = MPI_Unpack(pack_buf, pack_size, &pos, &array[start_idx], 1, type, MPI_COMM_SELF); check_err(MPI_Unpack); free(pack_buf); /* check against expected */ for (i = 0; i < size; ++i) { if (array[i] != expected[i]) { errs++; if (verbose) fprintf(stderr, "%s: array[%d]=%d, should be %d\n", name, i, array[i], expected[i]); } } return errs; } /* regression for tt#1030, checks for bad offset math in the * blockindexed and indexed dataloop flattening code */ int flatten_test(void) { int err, errs = 0; #define ARR_SIZE (9) /* real indices 0 1 2 3 4 5 6 7 8 * indices w/ &array[3] -3 -2 -1 0 1 2 3 4 5 */ int array[ARR_SIZE] = {-1,-1,-1,-1,-1,-1,-1,-1,-1}; int expected[ARR_SIZE] = {-1, 0, 1,-1, 2,-1, 3,-1, 4}; MPI_Datatype idx_type = MPI_DATATYPE_NULL; MPI_Datatype blkidx_type = MPI_DATATYPE_NULL; MPI_Datatype combo = MPI_DATATYPE_NULL; #define COUNT (2) int displ[COUNT]; MPI_Aint adispl[COUNT]; int blens[COUNT]; MPI_Datatype types[COUNT]; /* indexed type layout: * XX_X * 2101 <-- pos (left of 0 is neg) * * different blens to prevent optimization into a blockindexed */ blens[0] = 2; displ[0] = -2; /* elements, puts byte after block end at 0 */ blens[1] = 1; displ[1] = 1; /*elements*/ err = MPI_Type_indexed(COUNT, blens, displ, MPI_INT, &idx_type); check_err(MPI_Type_indexed); err = MPI_Type_commit(&idx_type); check_err(MPI_Type_commit); /* indexed type layout: * _X_X * 2101 <-- pos (left of 0 is neg) */ displ[0] = -1; displ[1] = 1; err = MPI_Type_create_indexed_block(COUNT, 1, displ, MPI_INT, &blkidx_type); check_err(MPI_Type_indexed_block); err = MPI_Type_commit(&blkidx_type); check_err(MPI_Type_commit); /* struct type layout: * II_I_B_B (I=idx_type, B=blkidx_type) * 21012345 <-- pos (left of 0 is neg) */ blens[0] = 1; adispl[0] = 0; /*bytes*/ types[0] = idx_type; blens[1] = 1; adispl[1] = 4 * sizeof(int); /* bytes */ types[1] = blkidx_type; /* must be a struct in order to trigger flattening code */ err = MPI_Type_create_struct(COUNT, blens, adispl, types, &combo); check_err(MPI_Type_indexed); err = MPI_Type_commit(&combo); check_err(MPI_Type_commit); /* pack/unpack with &array[3] */ errs += pack_and_check_expected(combo, "combo", 3, ARR_SIZE, array, expected); MPI_Type_free(&combo); MPI_Type_free(&idx_type); MPI_Type_free(&blkidx_type); return errs; #undef COUNT } #undef check_err int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/getpartelm.c000644 001750 001750 00000006112 12342443662 023302 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" /* static char MTest_descrip[] = "Receive partial datatypes and check that\ MPI_Getelements gives the correct version"; */ int main( int argc, char *argv[] ) { int errs = 0; MPI_Datatype outtype, oldtypes[2]; MPI_Aint offsets[2]; int blklens[2]; MPI_Comm comm; int size, rank, src, dest, tag; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); if (size < 2) { errs++; printf( "This test requires at least 2 processes\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } src = 0; dest = 1; if (rank == src) { int buf[128], position, cnt; /* sender */ /* Create a datatype and send it (multiple of sizeof(int)) */ /* Create a send struct type */ oldtypes[0] = MPI_INT; oldtypes[1] = MPI_CHAR; blklens[0] = 1; blklens[1] = 4*sizeof(int); offsets[0] = 0; offsets[1] = sizeof(int); MPI_Type_struct( 2, blklens, offsets, oldtypes, &outtype ); MPI_Type_commit( &outtype ); buf[0] = 4*sizeof(int); /* printf( "About to send to %d\n", dest ); */ MPI_Send( buf, 1, outtype, dest, 0, comm ); MPI_Type_free( &outtype ); /* Create a datatype and send it (not a multiple of sizeof(int)) */ /* Create a send struct type */ oldtypes[0] = MPI_INT; oldtypes[1] = MPI_CHAR; blklens[0] = 1; blklens[1] = 4*sizeof(int)+1; offsets[0] = 0; offsets[1] = sizeof(int); MPI_Type_struct( 2, blklens, offsets, oldtypes, &outtype ); MPI_Type_commit( &outtype ); buf[0] = 4*sizeof(int) + 1; MPI_Send( buf, 1, outtype, dest, 1, comm ); MPI_Type_free( &outtype ); /* Pack data and send as packed */ position = 0; cnt = 7; MPI_Pack( &cnt, 1, MPI_INT, buf, 128*sizeof(int), &position, comm ); MPI_Pack( (void*)"message", 7, MPI_CHAR, buf, 128*sizeof(int), &position, comm ); MPI_Send( buf, position, MPI_PACKED, dest, 2, comm ); } else if (rank == dest) { MPI_Status status; int buf[128], i, elms, count; /* Receiver */ /* Create a receive struct type */ oldtypes[0] = MPI_INT; oldtypes[1] = MPI_CHAR; blklens[0] = 1; blklens[1] = 256; offsets[0] = 0; offsets[1] = sizeof(int); MPI_Type_struct( 2, blklens, offsets, oldtypes, &outtype ); MPI_Type_commit( &outtype ); for (i=0; i<3; i++) { tag = i; /* printf( "about to receive tag %d from %d\n", i, src ); */ MPI_Recv( buf, 1, outtype, src, tag, comm, &status ); MPI_Get_elements( &status, outtype, &elms ); if (elms != buf[0] + 1) { errs++; printf( "For test %d, Get elements gave %d but should be %d\n", i, elms, buf[0] + 1 ); } MPI_Get_count( &status, outtype, &count ); if (count != MPI_UNDEFINED) { errs++; printf( "For partial send, Get_count did not return MPI_UNDEFINED\n" ); } } MPI_Type_free( &outtype ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/datatype/CMakeLists.txt000644 001750 001750 00000021536 12342443654 023542 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include/") # add_executable(blockindexed-misc blockindexed-misc.c) add_executable(blockindexed-zero-count blockindexed-zero-count.c) # add_executable(contents contents.c) # add_executable(contigstruct contigstruct.c) add_executable(contig-zero-count contig-zero-count.c) add_executable(cxx-types cxx-types.c) # add_executable(darray-cyclic darray-cyclic.c) # add_executable(darray-pack darray-pack.c) add_executable(gaddress gaddress.c) # add_executable(get-elements get-elements.c) # add_executable(get-elements-pairtype get-elements-pairtype.c) # add_executable(getpartelm getpartelm.c) add_executable(hindexed_block hindexed_block.c) add_executable(hindexed_block_contents hindexed_block_contents.c) # add_executable(hindexed-zeros hindexed-zeros.c) # add_executable(indexed-misc indexed-misc.c) # add_executable(large-count large-count.c) # add_executable(lbub lbub.c) # add_executable(localpack localpack.c) add_executable(longdouble longdouble.c) # add_executable(lots-of-types lots-of-types.c) # add_executable(pairtype-pack pairtype-pack.c) # add_executable(pairtype-size-extent pairtype-size-extent.c) add_executable(simple-commit simple-commit.c) # add_executable(simple-pack simple-pack.c) # add_executable(simple-pack-external simple-pack-external.c) # add_executable(simple-resized simple-resized.c) add_executable(simple-size-extent simple-size-extent.c) # add_executable(sizedtypes sizedtypes.c) # add_executable(slice-pack slice-pack.c) # add_executable(slice-pack-external slice-pack-external.c) add_executable(struct-derived-zeros struct-derived-zeros.c) # add_executable(struct-empty-el struct-empty-el.c) add_executable(struct-ezhov struct-ezhov.c) # add_executable(struct-no-real-types struct-no-real-types.c) # add_executable(struct-pack struct-pack.c) add_executable(struct-verydeep struct-verydeep.c) add_executable(struct-zero-count struct-zero-count.c) # add_executable(subarray subarray.c) # add_executable(subarray-pack subarray-pack.c) add_executable(tfree tfree.c) # add_executable(tmatchsize tmatchsize.c) # add_executable(transpose-pack transpose-pack.c) # add_executable(tresized2 tresized2.c) # add_executable(tresized tresized.c) # add_executable(triangular-pack triangular-pack.c) add_executable(typecommit typecommit.c) # add_executable(typefree typefree.c) add_executable(typelb typelb.c) # add_executable(typename typename.c) # add_executable(unpack unpack.c) # add_executable(unusual-noncontigs unusual-noncontigs.c) # add_executable(zero-blklen-vector zero-blklen-vector.c) # add_executable(zeroblks zeroblks.c) add_executable(zeroparms zeroparms.c) # target_link_libraries(blockindexed-misc simgrid mtest_c) target_link_libraries(blockindexed-zero-count simgrid mtest_c) # target_link_libraries(contents simgrid mtest_c) # target_link_libraries(contigstruct simgrid mtest_c) target_link_libraries(contig-zero-count simgrid mtest_c) target_link_libraries(cxx-types simgrid mtest_c) # target_link_libraries(darray-cyclic simgrid mtest_c) # target_link_libraries(darray-pack simgrid mtest_c) target_link_libraries(gaddress simgrid mtest_c) # target_link_libraries(get-elements simgrid mtest_c) # target_link_libraries(get-elements-pairtype simgrid mtest_c) # target_link_libraries(getpartelm simgrid mtest_c) target_link_libraries(hindexed_block simgrid mtest_c) target_link_libraries(hindexed_block_contents simgrid mtest_c) # target_link_libraries(hindexed-zeros simgrid mtest_c) # target_link_libraries(indexed-misc simgrid mtest_c) # target_link_libraries(large-count simgrid mtest_c) # target_link_libraries(lbub simgrid mtest_c) # target_link_libraries(localpack simgrid mtest_c) target_link_libraries(longdouble simgrid mtest_c) # target_link_libraries(lots-of-types simgrid mtest_c) # target_link_libraries(pairtype-pack simgrid mtest_c) # target_link_libraries(pairtype-size-extent simgrid mtest_c) target_link_libraries(simple-commit simgrid mtest_c) # target_link_libraries(simple-pack simgrid mtest_c) # target_link_libraries(simple-pack-external simgrid mtest_c) # target_link_libraries(simple-resized simgrid mtest_c) target_link_libraries(simple-size-extent simgrid mtest_c) # target_link_libraries(sizedtypes simgrid mtest_c) # target_link_libraries(slice-pack simgrid mtest_c) # target_link_libraries(slice-pack-external simgrid mtest_c) target_link_libraries(struct-derived-zeros simgrid mtest_c) # target_link_libraries(struct-empty-el simgrid mtest_c) target_link_libraries(struct-ezhov simgrid mtest_c) # target_link_libraries(struct-no-real-types simgrid mtest_c) # target_link_libraries(struct-pack simgrid mtest_c) target_link_libraries(struct-verydeep simgrid mtest_c) target_link_libraries(struct-zero-count simgrid mtest_c) # target_link_libraries(subarray simgrid mtest_c) # target_link_libraries(subarray-pack simgrid mtest_c) target_link_libraries(tfree simgrid mtest_c) # target_link_libraries(tmatchsize simgrid mtest_c) # target_link_libraries(transpose-pack simgrid mtest_c) # target_link_libraries(tresized2 simgrid mtest_c) # target_link_libraries(tresized simgrid mtest_c) # target_link_libraries(triangular-pack simgrid mtest_c) target_link_libraries(typecommit simgrid mtest_c) # target_link_libraries(typefree simgrid mtest_c) target_link_libraries(typelb simgrid mtest_c) # target_link_libraries(typename simgrid mtest_c) # target_link_libraries(unpack simgrid mtest_c) # target_link_libraries(unusual-noncontigs simgrid mtest_c) # target_link_libraries(zero-blklen-vector simgrid mtest_c) # target_link_libraries(zeroblks simgrid mtest_c) target_link_libraries(zeroparms simgrid mtest_c) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/blockindexed-misc.c ${CMAKE_CURRENT_SOURCE_DIR}/blockindexed-zero-count.c ${CMAKE_CURRENT_SOURCE_DIR}/contents.c ${CMAKE_CURRENT_SOURCE_DIR}/contigstruct.c ${CMAKE_CURRENT_SOURCE_DIR}/contig-zero-count.c ${CMAKE_CURRENT_SOURCE_DIR}/cxx-types.c ${CMAKE_CURRENT_SOURCE_DIR}/darray-cyclic.c ${CMAKE_CURRENT_SOURCE_DIR}/darray-pack.c ${CMAKE_CURRENT_SOURCE_DIR}/gaddress.c ${CMAKE_CURRENT_SOURCE_DIR}/get-elements.c ${CMAKE_CURRENT_SOURCE_DIR}/get-elements-pairtype.c ${CMAKE_CURRENT_SOURCE_DIR}/getpartelm.c ${CMAKE_CURRENT_SOURCE_DIR}/hindexed_block.c ${CMAKE_CURRENT_SOURCE_DIR}/hindexed_block_contents.c ${CMAKE_CURRENT_SOURCE_DIR}/hindexed-zeros.c ${CMAKE_CURRENT_SOURCE_DIR}/indexed-misc.c ${CMAKE_CURRENT_SOURCE_DIR}/large-count.c ${CMAKE_CURRENT_SOURCE_DIR}/lbub.c ${CMAKE_CURRENT_SOURCE_DIR}/localpack.c ${CMAKE_CURRENT_SOURCE_DIR}/longdouble.c ${CMAKE_CURRENT_SOURCE_DIR}/lots-of-types.c ${CMAKE_CURRENT_SOURCE_DIR}/pairtype-pack.c ${CMAKE_CURRENT_SOURCE_DIR}/pairtype-size-extent.c ${CMAKE_CURRENT_SOURCE_DIR}/simple-commit.c ${CMAKE_CURRENT_SOURCE_DIR}/simple-pack.c ${CMAKE_CURRENT_SOURCE_DIR}/simple-pack-external.c ${CMAKE_CURRENT_SOURCE_DIR}/simple-resized.c ${CMAKE_CURRENT_SOURCE_DIR}/simple-size-extent.c ${CMAKE_CURRENT_SOURCE_DIR}/sizedtypes.c ${CMAKE_CURRENT_SOURCE_DIR}/slice-pack.c ${CMAKE_CURRENT_SOURCE_DIR}/slice-pack-external.c ${CMAKE_CURRENT_SOURCE_DIR}/struct-derived-zeros.c ${CMAKE_CURRENT_SOURCE_DIR}/struct-empty-el.c ${CMAKE_CURRENT_SOURCE_DIR}/struct-ezhov.c ${CMAKE_CURRENT_SOURCE_DIR}/struct-no-real-types.c ${CMAKE_CURRENT_SOURCE_DIR}/struct-pack.c ${CMAKE_CURRENT_SOURCE_DIR}/struct-verydeep.c ${CMAKE_CURRENT_SOURCE_DIR}/struct-zero-count.c ${CMAKE_CURRENT_SOURCE_DIR}/subarray.c ${CMAKE_CURRENT_SOURCE_DIR}/subarray-pack.c ${CMAKE_CURRENT_SOURCE_DIR}/tfree.c ${CMAKE_CURRENT_SOURCE_DIR}/tmatchsize.c ${CMAKE_CURRENT_SOURCE_DIR}/transpose-pack.c ${CMAKE_CURRENT_SOURCE_DIR}/tresized2.c ${CMAKE_CURRENT_SOURCE_DIR}/tresized.c ${CMAKE_CURRENT_SOURCE_DIR}/triangular-pack.c ${CMAKE_CURRENT_SOURCE_DIR}/typecommit.c ${CMAKE_CURRENT_SOURCE_DIR}/typefree.c ${CMAKE_CURRENT_SOURCE_DIR}/typelb.c ${CMAKE_CURRENT_SOURCE_DIR}/typename.c ${CMAKE_CURRENT_SOURCE_DIR}/unpack.c ${CMAKE_CURRENT_SOURCE_DIR}/unusual-noncontigs.c ${CMAKE_CURRENT_SOURCE_DIR}/zero-blklen-vector.c ${CMAKE_CURRENT_SOURCE_DIR}/zeroblks.c ${CMAKE_CURRENT_SOURCE_DIR}/zeroparms.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/000755 001750 001750 00000000000 12342443666 020114 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/allgather3.c000644 001750 001750 00000003242 12342443661 022302 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitest.h" #include #include /* Gather data from a vector to contiguous. */ int main( int argc, char **argv ) { double *vecout, *invec; MPI_Comm comm; int count, minsize = 2; int i, errs = 0; int rank, size; MTest_Init( &argc, &argv ); while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); for (count = 1; count < 9000; count = count * 2) { invec = (double *)malloc( count * sizeof(double) ); vecout = (double *)malloc( size * count * sizeof(double) ); for (i=0; i #include "mpitest.h" void addem ( int *, int *, int *, MPI_Datatype * ); void addem(int *invec, int *inoutvec, int *len, MPI_Datatype *dtype) { int i; for ( i=0; i<*len; i++ ) inoutvec[i] += invec[i]; } int main( int argc, char **argv ) { int rank, size, i; int data; int errors=0; int result = -100; int correct_result; MPI_Op op; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); data = rank; MPI_Op_create( (MPI_User_function *)addem, 1, &op ); MPI_Reduce ( &data, &result, 1, MPI_INT, op, 0, MPI_COMM_WORLD ); MPI_Bcast ( &result, 1, MPI_INT, 0, MPI_COMM_WORLD ); MPI_Op_free( &op ); correct_result = 0; for(i=0;i #include #include "mpitest.h" #include /* static char MTEST_Descrip[] = "Test MPI_Allreduce with count greater than the number of processes"; */ /* We make the error count global so that we can easily control the output of error information (in particular, limiting it after the first 10 errors */ int errs = 0; int main( int argc, char *argv[] ) { MPI_Comm comm; MPI_Datatype dtype; int count, *bufin, *bufout, size, i, minsize=1; MTest_Init( &argc, &argv ); while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) { continue; } MPI_Comm_size( comm, &size ); count = size * 2; bufin = (int *)malloc( count * sizeof(int) ); bufout = (int *)malloc( count * sizeof(int) ); if (!bufin || !bufout) { fprintf( stderr, "Unable to allocated space for buffers (%d)\n", count ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } for (i=0; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_Allreduce with MPI_IN_PLACE"; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size; int minsize = 2, count; MPI_Comm comm; int *buf, i; MTest_Init( &argc, &argv ); while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); for (count = 1; count < 65000; count = count * 2) { /* Contiguous data */ buf = (int *)malloc( count * sizeof(int) ); for (i=0; i #include #include #include /* test broadcast behavior with non-zero counts but zero-sized types */ int main(int argc, char *argv[]) { int i, type_size; MPI_Datatype type = MPI_DATATYPE_NULL; int *buf = NULL; int wrank, wsize; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &wrank); MPI_Comm_size(MPI_COMM_WORLD, &wsize); /* a random non-zero sized buffer */ #define NELEM (10) buf = malloc(NELEM*sizeof(int)); assert(buf!=NULL); for (i = 0; i < NELEM; i++) { buf[i] = wrank * NELEM + i; } /* create a zero-size type */ MPI_Type_contiguous(0, MPI_INT, &type); MPI_Type_commit(&type); MPI_Type_size(type, &type_size); assert(type_size == 0); /* do the broadcast, which will break on some MPI implementations */ MPI_Bcast(buf, NELEM, type, 0, MPI_COMM_WORLD); /* check that the buffer remains unmolested */ for (i = 0; i < NELEM; i++) { assert(buf[i] == wrank * NELEM + i); } MPI_Type_free(&type); MPI_Finalize(); if (wrank == 0) { printf(" No errors\n"); } return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/icscatterv.c000644 001750 001750 00000005123 12342443661 022423 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple intercomm scatterv test"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int *buf = 0; int *sendcounts; int *senddispls; int leftGroup, i, count, rank, rsize, size; MPI_Comm comm; MPI_Datatype datatype; MTest_Init( &argc, &argv ); datatype = MPI_INT; /* Get an intercommunicator */ while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_remote_size( comm, &rsize ); MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN ); for (count = 1; count < 65000; count = 2 * count) { buf = 0; sendcounts = (int *)malloc( rsize * sizeof(int) ); senddispls = (int *)malloc( rsize * sizeof(int) ); for (i=0; i #include #define MAX_SIZE 64 MPI_Datatype transpose_type(int M, int m, int n, MPI_Datatype type); MPI_Datatype submatrix_type(int N, int m, int n, MPI_Datatype type); void Transpose(float *localA, float *localB, int M, int N, MPI_Comm comm); void Transpose(float *localA, float *localB, int M, int N, MPI_Comm comm) /* transpose MxN matrix A that is block distributed (1-D) on processes of comm onto block distributed matrix B */ { int i, j, extent, myrank, p, n[2], m[2]; int lasti, lastj; int *sendcounts, *recvcounts; int *sdispls, *rdispls; MPI_Datatype xtype[2][2], stype[2][2], *sendtypes, *recvtypes; MTestPrintfMsg( 2, "M = %d, N = %d\n", M, N ); /* compute parameters */ MPI_Comm_size(comm, &p); MPI_Comm_rank(comm, &myrank); extent = sizeof(float); /* allocate arrays */ sendcounts = (int *)malloc(p*sizeof(int)); recvcounts = (int *)malloc(p*sizeof(int)); sdispls = (int *)malloc(p*sizeof(int)); rdispls = (int *)malloc(p*sizeof(int)); sendtypes = (MPI_Datatype *)malloc(p*sizeof(MPI_Datatype)); recvtypes = (MPI_Datatype *)malloc(p*sizeof(MPI_Datatype)); /* compute block sizes */ m[0] = M/p; m[1] = M - (p-1)*(M/p); n[0] = N/p; n[1] = N - (p-1)*(N/p); /* compute types */ for (i=0; i <= 1; i++) for (j=0; j <= 1; j++) { xtype[i][j] = transpose_type(N, m[i], n[j], MPI_FLOAT); stype[i][j] = submatrix_type(M, m[i], n[j], MPI_FLOAT); } /* prepare collective operation arguments */ lasti = myrank == p-1; for (j=0; j < p; j++) { lastj = j == p-1; sendcounts[j] = 1; sdispls[j] = j*n[0]*extent; sendtypes[j] = xtype[lasti][lastj]; recvcounts[j] = 1; rdispls[j] = j*m[0]*extent; recvtypes[j] = stype[lastj][lasti]; } /* communicate */ MTestPrintfMsg( 2, "Begin Alltoallw...\n" ); /* -- Note that the book incorrectly uses &localA and &localB as arguments to MPI_Alltoallw */ MPI_Alltoallw(localA, sendcounts, sdispls, sendtypes, localB, recvcounts, rdispls, recvtypes, comm); MTestPrintfMsg( 2, "Done with Alltoallw\n" ); /* Free buffers */ free( sendcounts ); free( recvcounts ); free( sdispls ); free( rdispls ); free( sendtypes ); free( recvtypes ); /* Free datatypes */ for (i=0; i <= 1; i++) for (j=0; j <= 1; j++) { MPI_Type_free( &xtype[i][j] ); MPI_Type_free( &stype[i][j] ); } } /* Define an n x m submatrix in a n x M local matrix (this is the destination in the transpose matrix */ MPI_Datatype submatrix_type(int M, int m, int n, MPI_Datatype type) /* computes a datatype for an mxn submatrix within an MxN matrix with entries of type type */ { /* MPI_Datatype subrow; */ MPI_Datatype submatrix; /* The book, MPI: The Complete Reference, has the wrong type constructor here. Since the stride in the vector type is relative to the input type, the stride in the book's code is n times as long as is intended. Since n may not exactly divide N, it is better to simply use the blocklength argument in Type_vector */ /* MPI_Type_contiguous(n, type, &subrow); MPI_Type_vector(m, 1, N, subrow, &submatrix); */ MPI_Type_vector(n, m, M, type, &submatrix ); MPI_Type_commit(&submatrix); /* Add a consistency test: the size of submatrix should be n * m * sizeof(type) and the extent should be ((n-1)*M+m) * sizeof(type) */ { int tsize; MPI_Aint textent, lb; MPI_Type_size( type, &tsize ); MPI_Type_get_extent( submatrix, &lb, &textent ); if (textent != tsize * (M * (n-1)+m)) { fprintf( stderr, "Submatrix extent is %ld, expected %ld (%d,%d,%d)\n", (long)textent, (long)(tsize * (M * (n-1)+m)), M, n, m ); } } return(submatrix); } /* Extract an m x n submatrix within an m x N matrix and transpose it. Assume storage by rows; the defined datatype accesses by columns */ MPI_Datatype transpose_type(int N, int m, int n, MPI_Datatype type) /* computes a datatype for the transpose of an mxn matrix with entries of type type */ { MPI_Datatype subrow, subrow1, submatrix; MPI_Aint lb, extent; MPI_Type_vector(m, 1, N, type, &subrow); MPI_Type_get_extent(type, &lb, &extent); MPI_Type_create_resized(subrow, 0, extent, &subrow1); MPI_Type_contiguous(n, subrow1, &submatrix); MPI_Type_commit(&submatrix); MPI_Type_free( &subrow ); MPI_Type_free( &subrow1 ); /* Add a consistency test: the size of submatrix should be n * m * sizeof(type) and the extent should be ((m-1)*N+n) * sizeof(type) */ { int tsize; MPI_Aint textent, llb; MPI_Type_size( type, &tsize ); MPI_Type_get_true_extent( submatrix, &llb, &textent ); if (textent != tsize * (N * (m-1)+n)) { fprintf( stderr, "Transpose Submatrix extent is %ld, expected %ld (%d,%d,%d)\n", (long)textent, (long)(tsize * (N * (m-1)+n)), N, n, m ); } } return(submatrix); } /* -- CUT HERE -- */ int main( int argc, char *argv[] ) { int gM, gN, lm, lmlast, ln, lnlast, i, j, errs = 0; int size, rank; float *localA, *localB; MPI_Comm comm; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); gM = 20; gN = 30; /* Each block is lm x ln in size, except for the last process, which has lmlast x lnlast */ lm = gM/size; lmlast = gM - (size - 1)*lm; ln = gN/size; lnlast = gN - (size - 1)*ln; /* Create the local matrices. Initialize the input matrix so that the entries are consequtive integers, by row, starting at 0. */ if (rank == size - 1) { localA = (float *)malloc( gN * lmlast * sizeof(float) ); localB = (float *)malloc( gM * lnlast * sizeof(float) ); for (i=0; i #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_MINLOC operations on datatypes dupported by MPICH"; */ /* * This test looks at the handling of char and types that are not required * integers (e.g., long long). MPICH allows * these as well. A strict MPI test should not include this test. * * The rule on min loc is that if there is a tie in the value, the minimum * rank is used (see 4.9.3 in the MPI-1 standard) */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size; MPI_Comm comm; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); /* 2 int */ { struct twoint { int val; int loc; } cinbuf[3], coutbuf[3]; cinbuf[0].val = 1; cinbuf[0].loc = rank; cinbuf[1].val = 0; cinbuf[1].loc = rank; cinbuf[2].val = (rank & 0x7f); cinbuf[2].loc = rank; coutbuf[0].val = 0; coutbuf[0].loc = -1; coutbuf[1].val = 1; coutbuf[1].loc = -1; coutbuf[2].val = 1; coutbuf[2].loc = -1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_2INT, MPI_MINLOC, 0, comm ); if (rank == 0) { if (coutbuf[0].val != 1 && coutbuf[0].loc != -1) { errs++; fprintf( stderr, "2int MINLOC(1) test failed\n" ); } if (coutbuf[1].val != 0 && coutbuf[1].loc != -1) { errs++; fprintf( stderr, "2int MINLOC(0) test failed\n" ); } if (coutbuf[2].val != 0 && coutbuf[2].loc != 0) { errs++; fprintf( stderr, "2int MINLOC(>) test failed\n" ); } } } /* float int */ { struct floatint { float val; int loc; } cinbuf[3], coutbuf[3]; cinbuf[0].val = 1; cinbuf[0].loc = rank; cinbuf[1].val = 0; cinbuf[1].loc = rank; cinbuf[2].val = (float)rank; cinbuf[2].loc = rank; coutbuf[0].val = 0; coutbuf[0].loc = -1; coutbuf[1].val = 1; coutbuf[1].loc = -1; coutbuf[2].val = 1; coutbuf[2].loc = -1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_FLOAT_INT, MPI_MINLOC, 0, comm ); if (rank == 0) { if (coutbuf[0].val != 1 && coutbuf[0].loc != -1) { errs++; fprintf( stderr, "float-int MINLOC(1) test failed\n" ); } if (coutbuf[1].val != 0 && coutbuf[1].loc != -1) { errs++; fprintf( stderr, "float-int MINLOC(0) test failed\n" ); } if (coutbuf[2].val != 0 && coutbuf[2].loc != 0) { errs++; fprintf( stderr, "float-int MINLOC(>) test failed\n" ); } } } /* long int */ { struct longint { long val; int loc; } cinbuf[3], coutbuf[3]; cinbuf[0].val = 1; cinbuf[0].loc = rank; cinbuf[1].val = 0; cinbuf[1].loc = rank; cinbuf[2].val = rank; cinbuf[2].loc = rank; coutbuf[0].val = 0; coutbuf[0].loc = -1; coutbuf[1].val = 1; coutbuf[1].loc = -1; coutbuf[2].val = 1; coutbuf[2].loc = -1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_LONG_INT, MPI_MINLOC, 0, comm ); if (rank == 0) { if (coutbuf[0].val != 1 || coutbuf[0].loc != 0) { errs++; fprintf( stderr, "long-int MINLOC(1) test failed\n" ); } if (coutbuf[1].val != 0 || coutbuf[1].loc != 0) { errs++; fprintf( stderr, "long-int MINLOC(0) test failed\n" ); } if (coutbuf[2].val != 0 || coutbuf[2].loc != 0) { errs++; fprintf( stderr, "long-int MINLOC(>) test failed\n" ); } } } /* short int */ { struct shortint { short val; int loc; } cinbuf[3], coutbuf[3]; cinbuf[0].val = 1; cinbuf[0].loc = rank; cinbuf[1].val = 0; cinbuf[1].loc = rank; cinbuf[2].val = rank; cinbuf[2].loc = rank; coutbuf[0].val = 0; coutbuf[0].loc = -1; coutbuf[1].val = 1; coutbuf[1].loc = -1; coutbuf[2].val = 1; coutbuf[2].loc = -1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_SHORT_INT, MPI_MINLOC, 0, comm ); if (rank == 0) { if (coutbuf[0].val != 1 || coutbuf[0].loc != 0) { errs++; fprintf( stderr, "short-int MINLOC(1) test failed\n" ); } if (coutbuf[1].val != 0 || coutbuf[1].loc != 0) { errs++; fprintf( stderr, "short-int MINLOC(0) test failed\n" ); } if (coutbuf[2].val != 0 || coutbuf[2].loc != 0) { errs++; fprintf( stderr, "short-int MINLOC(>) test failed\n" ); } } } /* double int */ { struct doubleint { double val; int loc; } cinbuf[3], coutbuf[3]; cinbuf[0].val = 1; cinbuf[0].loc = rank; cinbuf[1].val = 0; cinbuf[1].loc = rank; cinbuf[2].val = rank; cinbuf[2].loc = rank; coutbuf[0].val = 0; coutbuf[0].loc = -1; coutbuf[1].val = 1; coutbuf[1].loc = -1; coutbuf[2].val = 1; coutbuf[2].loc = -1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_DOUBLE_INT, MPI_MINLOC, 0, comm ); if (rank == 0) { if (coutbuf[0].val != 1 || coutbuf[0].loc != 0) { errs++; fprintf( stderr, "double-int MINLOC(1) test failed\n" ); } if (coutbuf[1].val != 0 || coutbuf[1].loc != 0) { errs++; fprintf( stderr, "double-int MINLOC(0) test failed\n" ); } if (coutbuf[2].val != 0 || coutbuf[2].loc != 0) { errs++; fprintf( stderr, "double-int MINLOC(>) test failed\n" ); } } } #ifdef HAVE_LONG_DOUBLE /* long double int */ { struct longdoubleint { long double val; int loc; } cinbuf[3], coutbuf[3]; cinbuf[0].val = 1; cinbuf[0].loc = rank; cinbuf[1].val = 0; cinbuf[1].loc = rank; cinbuf[2].val = rank; cinbuf[2].loc = rank; coutbuf[0].val = 0; coutbuf[0].loc = -1; coutbuf[1].val = 1; coutbuf[1].loc = -1; coutbuf[2].val = 1; coutbuf[2].loc = -1; if (MPI_LONG_DOUBLE != MPI_DATATYPE_NULL) { MPI_Reduce( cinbuf, coutbuf, 3, MPI_LONG_DOUBLE_INT, MPI_MINLOC, 0, comm ); if (rank == 0) { if (coutbuf[0].val != 1 || coutbuf[0].loc != 0) { errs++; fprintf( stderr, "long double-int MINLOC(1) test failed\n" ); } if (coutbuf[1].val != 0 || coutbuf[1].loc != 0) { errs++; fprintf( stderr, "long double-int MINLOC(0) test failed\n" ); } if (coutbuf[2].val != 0 || coutbuf[2].loc != 0) { errs++; fprintf( stderr, "long double-int MINLOC(>) test failed\n" ); } } } } #endif MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/opmaxloc.c000644 001750 001750 00000017372 12342443661 022107 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitestconf.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_MAXLOC operations on datatypes dupported by MPICH"; */ /* * This test looks at the handling of char and types that are not required * integers (e.g., long long). MPICH allows * these as well. A strict MPI test should not include this test. * * The rule on max loc is that if there is a tie in the value, the minimum * rank is used (see 4.9.3 in the MPI-1 standard) */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size; MPI_Comm comm; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); /* 2 int */ { struct twoint { int val; int loc; } cinbuf[3], coutbuf[3]; cinbuf[0].val = 1; cinbuf[0].loc = rank; cinbuf[1].val = 0; cinbuf[1].loc = rank; cinbuf[2].val = rank; cinbuf[2].loc = rank; coutbuf[0].val = 0; coutbuf[0].loc = -1; coutbuf[1].val = 1; coutbuf[1].loc = -1; coutbuf[2].val = 1; coutbuf[2].loc = -1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_2INT, MPI_MAXLOC, 0, comm ); if (rank == 0) { if (coutbuf[0].val != 1 || coutbuf[0].loc != 0) { errs++; fprintf( stderr, "2int MAXLOC(1) test failed\n" ); } if (coutbuf[1].val != 0) { errs++; fprintf( stderr, "2int MAXLOC(0) test failed, value = %d, should be zero\n", coutbuf[1].val ); } if (coutbuf[1].loc != 0) { errs++; fprintf( stderr, "2int MAXLOC(0) test failed, location of max = %d, should be zero\n", coutbuf[1].loc ); } if (coutbuf[2].val != size-1 || coutbuf[2].loc != size-1) { errs++; fprintf( stderr, "2int MAXLOC(>) test failed\n" ); } } } /* float int */ { struct floatint { float val; int loc; } cinbuf[3], coutbuf[3]; cinbuf[0].val = 1; cinbuf[0].loc = rank; cinbuf[1].val = 0; cinbuf[1].loc = rank; cinbuf[2].val = (float)rank; cinbuf[2].loc = rank; coutbuf[0].val = 0; coutbuf[0].loc = -1; coutbuf[1].val = 1; coutbuf[1].loc = -1; coutbuf[2].val = 1; coutbuf[2].loc = -1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_FLOAT_INT, MPI_MAXLOC, 0, comm ); if (rank == 0) { if (coutbuf[0].val != 1 || coutbuf[0].loc != 0) { errs++; fprintf( stderr, "float-int MAXLOC(1) test failed\n" ); } if (coutbuf[1].val != 0) { errs++; fprintf( stderr, "float-int MAXLOC(0) test failed, value = %f, should be zero\n", coutbuf[1].val ); } if (coutbuf[1].loc != 0) { errs++; fprintf( stderr, "float-int MAXLOC(0) test failed, location of max = %d, should be zero\n", coutbuf[1].loc ); } if (coutbuf[2].val != size-1 || coutbuf[2].loc != size-1) { errs++; fprintf( stderr, "float-int MAXLOC(>) test failed\n" ); } } } /* long int */ { struct longint { long val; int loc; } cinbuf[3], coutbuf[3]; cinbuf[0].val = 1; cinbuf[0].loc = rank; cinbuf[1].val = 0; cinbuf[1].loc = rank; cinbuf[2].val = rank; cinbuf[2].loc = rank; coutbuf[0].val = 0; coutbuf[0].loc = -1; coutbuf[1].val = 1; coutbuf[1].loc = -1; coutbuf[2].val = 1; coutbuf[2].loc = -1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_LONG_INT, MPI_MAXLOC, 0, comm ); if (rank == 0) { if (coutbuf[0].val != 1 || coutbuf[0].loc != 0) { errs++; fprintf( stderr, "long-int MAXLOC(1) test failed\n" ); } if (coutbuf[1].val != 0) { errs++; fprintf( stderr, "long-int MAXLOC(0) test failed, value = %ld, should be zero\n", coutbuf[1].val ); } if (coutbuf[1].loc != 0) { errs++; fprintf( stderr, "long-int MAXLOC(0) test failed, location of max = %d, should be zero\n", coutbuf[1].loc ); } if (coutbuf[2].val != size-1 || coutbuf[2].loc != size-1) { errs++; fprintf( stderr, "long-int MAXLOC(>) test failed\n" ); } } } /* short int */ { struct shortint { short val; int loc; } cinbuf[3], coutbuf[3]; cinbuf[0].val = 1; cinbuf[0].loc = rank; cinbuf[1].val = 0; cinbuf[1].loc = rank; cinbuf[2].val = rank; cinbuf[2].loc = rank; coutbuf[0].val = 0; coutbuf[0].loc = -1; coutbuf[1].val = 1; coutbuf[1].loc = -1; coutbuf[2].val = 1; coutbuf[2].loc = -1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_SHORT_INT, MPI_MAXLOC, 0, comm ); if (rank == 0) { if (coutbuf[0].val != 1 || coutbuf[0].loc != 0) { errs++; fprintf( stderr, "short-int MAXLOC(1) test failed\n" ); } if (coutbuf[1].val != 0) { errs++; fprintf( stderr, "short-int MAXLOC(0) test failed, value = %d, should be zero\n", coutbuf[1].val ); } if (coutbuf[1].loc != 0) { errs++; fprintf( stderr, "short-int MAXLOC(0) test failed, location of max = %d, should be zero\n", coutbuf[1].loc ); } if (coutbuf[2].val != size-1) { errs++; fprintf( stderr, "short-int MAXLOC(>) test failed, value = %d, should be %d\n", coutbuf[2].val, size-1 ); } if (coutbuf[2].loc != size -1) { errs++; fprintf( stderr, "short-int MAXLOC(>) test failed, location of max = %d, should be %d\n", coutbuf[2].loc, size-1 ); } } } /* double int */ { struct doubleint { double val; int loc; } cinbuf[3], coutbuf[3]; cinbuf[0].val = 1; cinbuf[0].loc = rank; cinbuf[1].val = 0; cinbuf[1].loc = rank; cinbuf[2].val = rank; cinbuf[2].loc = rank; coutbuf[0].val = 0; coutbuf[0].loc = -1; coutbuf[1].val = 1; coutbuf[1].loc = -1; coutbuf[2].val = 1; coutbuf[2].loc = -1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_DOUBLE_INT, MPI_MAXLOC, 0, comm ); if (rank == 0) { if (coutbuf[0].val != 1 || coutbuf[0].loc != 0) { errs++; fprintf( stderr, "double-int MAXLOC(1) test failed\n" ); } if (coutbuf[1].val != 0) { errs++; fprintf( stderr, "double-int MAXLOC(0) test failed, value = %f, should be zero\n", coutbuf[1].val ); } if (coutbuf[1].loc != 0) { errs++; fprintf( stderr, "double-int MAXLOC(0) test failed, location of max = %d, should be zero\n", coutbuf[1].loc ); } if (coutbuf[2].val != size-1 || coutbuf[2].loc != size-1) { errs++; fprintf( stderr, "double-int MAXLOC(>) test failed\n" ); } } } #ifdef HAVE_LONG_DOUBLE /* long double int */ { struct longdoubleint { long double val; int loc; } cinbuf[3], coutbuf[3]; /* avoid valgrind warnings about padding bytes in the long double */ memset(&cinbuf[0], 0, sizeof(cinbuf)); memset(&coutbuf[0], 0, sizeof(coutbuf)); cinbuf[0].val = 1; cinbuf[0].loc = rank; cinbuf[1].val = 0; cinbuf[1].loc = rank; cinbuf[2].val = rank; cinbuf[2].loc = rank; coutbuf[0].val = 0; coutbuf[0].loc = -1; coutbuf[1].val = 1; coutbuf[1].loc = -1; coutbuf[2].val = 1; coutbuf[2].loc = -1; if (MPI_LONG_DOUBLE != MPI_DATATYPE_NULL) { MPI_Reduce( cinbuf, coutbuf, 3, MPI_LONG_DOUBLE_INT, MPI_MAXLOC, 0, comm ); if (rank == 0) { if (coutbuf[0].val != 1 || coutbuf[0].loc != 0) { errs++; fprintf( stderr, "long double-int MAXLOC(1) test failed\n" ); } if (coutbuf[1].val != 0) { errs++; fprintf( stderr, "long double-int MAXLOC(0) test failed, value = %f, should be zero\n", (double)coutbuf[1].val ); } if (coutbuf[1].loc != 0) { errs++; fprintf( stderr, "long double-int MAXLOC(0) test failed, location of max = %d, should be zero\n", coutbuf[1].loc ); } if (coutbuf[2].val != size-1) { errs++; fprintf( stderr, "long double-int MAXLOC(>) test failed, value = %f, should be %d\n", (double)coutbuf[2].val, size-1 ); } if (coutbuf[2].loc != size-1) { errs++; fprintf( stderr, "long double-int MAXLOC(>) test failed, location of max = %d, should be %d\n", coutbuf[2].loc, size-1 ); } } } } #endif MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/scatter3.c000644 001750 001750 00000004775 12342443661 022020 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitest.h" #include #include /* This example sends contiguous data and receives a vector on some nodes and contiguous data on others. There is some evidence that some MPI implementations do not check recvcount on the root process; this test checks for that case */ int main( int argc, char **argv ) { MPI_Datatype vec; double *vecin, *vecout, ivalue; int root, i, n, stride, errs = 0; int rank, size; MPI_Aint vextent; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); n = 12; stride = 10; /* Note that vecout really needs to be only (n-1)*stride+1 doubles, but this is easier and allows a little extra room if there is a bug */ vecout = (double *)malloc( n * stride * sizeof(double) ); vecin = (double *)malloc( n * size * sizeof(double) ); MPI_Type_vector( n, 1, stride, MPI_DOUBLE, &vec ); MPI_Type_commit( &vec ); MPI_Type_extent( vec, &vextent ); if (vextent != ((n-1)*(MPI_Aint)stride + 1) * sizeof(double) ) { errs++; printf( "Vector extent is %ld, should be %ld\n", (long) vextent, (long)(((n-1)*stride+1)*sizeof(double)) ); } /* Note that the exted of type vector is from the first to the last element, not n*stride. E.g., with n=1, the extent is a single double */ for (i=0; i #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_MIN operations on optional datatypes dupported by MPICH"; */ /* * This test looks at the handling of char and types that are not required * integers (e.g., long long). MPICH allows * these as well. A strict MPI test should not include this test. */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size; MPI_Comm comm; char cinbuf[3], coutbuf[3]; signed char scinbuf[3], scoutbuf[3]; unsigned char ucinbuf[3], ucoutbuf[3]; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); #ifndef USE_STRICT_MPI /* char */ MTestPrintfMsg( 10, "Reduce of MPI_CHAR\n" ); cinbuf[0] = 1; cinbuf[1] = 0; cinbuf[2] = (rank & 0x7f); coutbuf[0] = 0; coutbuf[1] = 1; coutbuf[2] = 1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_CHAR, MPI_MIN, 0, comm ); if (rank == 0) { if (coutbuf[0] != 1) { errs++; fprintf( stderr, "char MIN(1) test failed\n" ); } if (coutbuf[1] != 0) { errs++; fprintf( stderr, "char MIN(0) test failed\n" ); } if (coutbuf[2] != 0) { errs++; fprintf( stderr, "char MIN(>) test failed\n" ); } } #endif /* USE_STRICT_MPI */ /* signed char */ MTestPrintfMsg( 10, "Reduce of MPI_SIGNED_CHAR\n" ); scinbuf[0] = 1; scinbuf[1] = 0; scinbuf[2] = (rank & 0x7f); scoutbuf[0] = 0; scoutbuf[1] = 1; scoutbuf[2] = 1; MPI_Reduce( scinbuf, scoutbuf, 3, MPI_SIGNED_CHAR, MPI_MIN, 0, comm ); if (rank == 0) { if (scoutbuf[0] != 1) { errs++; fprintf( stderr, "signed char MIN(1) test failed\n" ); } if (scoutbuf[1] != 0) { errs++; fprintf( stderr, "signed char MIN(0) test failed\n" ); } if (scoutbuf[2] != 0) { errs++; fprintf( stderr, "signed char MIN(>) test failed\n" ); } } /* unsigned char */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_CHAR\n" ); ucinbuf[0] = 1; ucinbuf[1] = 0; ucinbuf[2] = (rank & 0x7f); ucoutbuf[0] = 0; ucoutbuf[1] = 1; ucoutbuf[2] = 1; MPI_Reduce( ucinbuf, ucoutbuf, 3, MPI_UNSIGNED_CHAR, MPI_MIN, 0, comm ); if (rank == 0) { if (ucoutbuf[0] != 1) { errs++; fprintf( stderr, "unsigned char MIN(1) test failed\n" ); } if (ucoutbuf[1]) { errs++; fprintf( stderr, "unsigned char MIN(0) test failed\n" ); } if (ucoutbuf[2] != 0) { errs++; fprintf( stderr, "unsigned char MIN(>) test failed\n" ); } } #ifdef HAVE_LONG_DOUBLE { long double ldinbuf[3], ldoutbuf[3]; /* long double */ ldinbuf[0] = 1; ldinbuf[1] = 0; ldinbuf[2] = rank; ldoutbuf[0] = 0; ldoutbuf[1] = 1; ldoutbuf[2] = 1; if (MPI_LONG_DOUBLE != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_DOUBLE\n" ); MPI_Reduce( ldinbuf, ldoutbuf, 3, MPI_LONG_DOUBLE, MPI_MIN, 0, comm ); if (rank == 0) { if (ldoutbuf[0] != 1) { errs++; fprintf( stderr, "long double MIN(1) test failed\n" ); } if (ldoutbuf[1] != 0.0) { errs++; fprintf( stderr, "long double MIN(0) test failed\n" ); } if (ldoutbuf[2] != 0.0) { errs++; fprintf( stderr, "long double MIN(>) test failed\n" ); } } } } #endif /* HAVE_LONG_DOUBLE */ #ifdef HAVE_LONG_LONG { long long llinbuf[3], lloutbuf[3]; /* long long */ llinbuf[0] = 1; llinbuf[1] = 0; llinbuf[2] = rank; lloutbuf[0] = 0; lloutbuf[1] = 1; lloutbuf[2] = 1; if (MPI_LONG_LONG != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_LONG\n" ); MPI_Reduce( llinbuf, lloutbuf, 3, MPI_LONG_LONG, MPI_MIN, 0, comm ); if (rank == 0) { if (lloutbuf[0] != 1) { errs++; fprintf( stderr, "long long MIN(1) test failed\n" ); } if (lloutbuf[1] != 0) { errs++; fprintf( stderr, "long long MIN(0) test failed\n" ); } if (lloutbuf[2] != 0) { errs++; fprintf( stderr, "long long MIN(>) test failed\n" ); } } } } #endif /* HAVE_LONG_LONG */ MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/allgatherv4.c000644 001750 001750 00000020103 12342443661 022464 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitest.h" #include "smpi_cocci.h" #include #include #ifdef HAVE_SYS_TIME_H #include #endif #include #include #include /* FIXME: What is this test supposed to accomplish? */ #define START_BUF (1) #define LARGE_BUF (256 * 1024) /* FIXME: MAX_BUF is too large */ #define MAX_BUF (32 * 1024 * 1024) #define LOOPS 10 SMPI_VARINIT_GLOBAL(sbuf, char*); SMPI_VARINIT_GLOBAL(rbuf, char*); SMPI_VARINIT_GLOBAL(recvcounts, int*); SMPI_VARINIT_GLOBAL(displs, int*); SMPI_VARINIT_GLOBAL_AND_SET(errs, int, 0); /* #define dprintf printf */ #define dprintf(...) typedef enum { REGULAR, BCAST, SPIKE, HALF_FULL, LINEAR_DECREASE, BELL_CURVE } test_t; void comm_tests(MPI_Comm comm); double run_test(long long msg_size, MPI_Comm comm, test_t test_type, double * max_time); int main(int argc, char ** argv) { int comm_size, comm_rank; MPI_Comm comm; MTest_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &comm_size); MPI_Comm_rank(MPI_COMM_WORLD, &comm_rank); if (LARGE_BUF * comm_size > MAX_BUF) goto fn_exit; SMPI_VARGET_GLOBAL(sbuf) = (void *) calloc(MAX_BUF, 1); SMPI_VARGET_GLOBAL(rbuf) = (void *) calloc(MAX_BUF, 1); srand(time(NULL)); SMPI_VARGET_GLOBAL(recvcounts) = (void *) malloc(comm_size * sizeof(int)); SMPI_VARGET_GLOBAL(displs) = (void *) malloc(comm_size * sizeof(int)); if (!SMPI_VARGET_GLOBAL(recvcounts) || !SMPI_VARGET_GLOBAL(displs) || !SMPI_VARGET_GLOBAL(sbuf) || !SMPI_VARGET_GLOBAL(rbuf)) { fprintf(stderr, "Unable to allocate memory:\n"); if (!SMPI_VARGET_GLOBAL(sbuf)) fprintf(stderr,"\tsbuf of %d bytes\n", MAX_BUF ); if (!SMPI_VARGET_GLOBAL(rbuf)) fprintf(stderr,"\trbuf of %d bytes\n", MAX_BUF ); if (!SMPI_VARGET_GLOBAL(recvcounts)) fprintf(stderr,"\trecvcounts of %zd bytes\n", comm_size * sizeof(int) ); if (!SMPI_VARGET_GLOBAL(displs)) fprintf(stderr,"\tdispls of %zd bytes\n", comm_size * sizeof(int) ); fflush(stderr); MPI_Abort(MPI_COMM_WORLD, -1); exit(-1); } if (!comm_rank) { dprintf("Message Range: (%d, %d); System size: %d\n", START_BUF, LARGE_BUF, comm_size); fflush(stdout); } /* COMM_WORLD tests */ if (!comm_rank) { dprintf("\n\n==========================================================\n"); dprintf(" MPI_COMM_WORLD\n"); dprintf("==========================================================\n"); } comm_tests(MPI_COMM_WORLD); /* non-COMM_WORLD tests */ if (!comm_rank) { dprintf("\n\n==========================================================\n"); dprintf(" non-COMM_WORLD\n"); dprintf("==========================================================\n"); } MPI_Comm_split(MPI_COMM_WORLD, (comm_rank == comm_size - 1) ? 0 : 1, 0, &comm); if (comm_rank < comm_size - 1) comm_tests(comm); MPI_Comm_free(&comm); /* Randomized communicator tests */ if (!comm_rank) { dprintf("\n\n==========================================================\n"); dprintf(" Randomized Communicator\n"); dprintf("==========================================================\n"); } MPI_Comm_split(MPI_COMM_WORLD, 0, rand(), &comm); comm_tests(comm); MPI_Comm_free(&comm); //free(SMPI_VARGET_GLOBAL(sbuf)); //free(SMPI_VARGET_GLOBAL(rbuf)); free(SMPI_VARGET_GLOBAL(recvcounts)); free(SMPI_VARGET_GLOBAL(displs)); fn_exit: MTest_Finalize(SMPI_VARGET_GLOBAL(errs)); MPI_Finalize(); return 0; } void comm_tests(MPI_Comm comm) { int comm_size, comm_rank; double rtime = rtime; /* stop warning about unused variable */ double max_time; long long msg_size; MPI_Comm_size(comm, &comm_size); MPI_Comm_rank(comm, &comm_rank); for (msg_size = START_BUF; msg_size <= LARGE_BUF; msg_size *= 2) { if (!comm_rank) { dprintf("\n====> MSG_SIZE: %d\n", (int) msg_size); fflush(stdout); } rtime = run_test(msg_size, comm, REGULAR, &max_time); if (!comm_rank) { dprintf("REGULAR:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time); fflush(stdout); } rtime = run_test(msg_size, comm, BCAST, &max_time); if (!comm_rank) { dprintf("BCAST:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time); fflush(stdout); } rtime = run_test(msg_size, comm, SPIKE, &max_time); if (!comm_rank) { dprintf("SPIKE:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time); fflush(stdout); } rtime = run_test(msg_size, comm, HALF_FULL, &max_time); if (!comm_rank) { dprintf("HALF_FULL:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time); fflush(stdout); } rtime = run_test(msg_size, comm, LINEAR_DECREASE, &max_time); if (!comm_rank) { dprintf("LINEAR_DECREASE:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time); fflush(stdout); } rtime = run_test(msg_size, comm, BELL_CURVE, &max_time); if (!comm_rank) { dprintf("BELL_CURVE:\tAVG: %.3f\tMAX: %.3f\n", rtime, max_time); fflush(stdout); } } } double run_test(long long msg_size, MPI_Comm comm, test_t test_type, double * max_time) { int i, j; int comm_size, comm_rank; double start, end; double total_time, avg_time; MPI_Aint tmp; MPI_Comm_size(comm, &comm_size); MPI_Comm_rank(comm, &comm_rank); SMPI_VARGET_GLOBAL(displs)[0] = 0; for (i = 0; i < comm_size; i++) { if (test_type == REGULAR) SMPI_VARGET_GLOBAL(recvcounts)[i] = msg_size; else if (test_type == BCAST) SMPI_VARGET_GLOBAL(recvcounts)[i] = (!i) ? msg_size : 0; else if (test_type == SPIKE) SMPI_VARGET_GLOBAL(recvcounts)[i] = (!i) ? (msg_size / 2) : (msg_size / (2 * (comm_size - 1))); else if (test_type == HALF_FULL) SMPI_VARGET_GLOBAL(recvcounts)[i] = (i < (comm_size / 2)) ? (2 * msg_size) : 0; else if (test_type == LINEAR_DECREASE) { tmp = 2 * msg_size * (comm_size - 1 - i) / (comm_size - 1); if (tmp != (int)tmp) { fprintf( stderr, "Integer overflow in variable tmp\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } SMPI_VARGET_GLOBAL(recvcounts)[i] = (int) tmp; /* If the maximum message size is too large, don't run */ if (tmp > MAX_BUF) return 0; } else if (test_type == BELL_CURVE) { for (j = 0; j < i; j++) { if (i - 1 + j >= comm_size) continue; tmp = msg_size * comm_size / (log(comm_size) * i); SMPI_VARGET_GLOBAL(recvcounts)[i - 1 + j] = (int) tmp; SMPI_VARGET_GLOBAL(displs)[i - 1 + j] = 0; /* If the maximum message size is too large, don't run */ if (tmp > MAX_BUF) return 0; } } if (i < comm_size - 1) SMPI_VARGET_GLOBAL(displs)[i+1] = SMPI_VARGET_GLOBAL(displs)[i] + SMPI_VARGET_GLOBAL(recvcounts)[i]; } /* Test that: 1: sbuf is large enough 2: rbuf is large enough 3: There were no failures (e.g., tmp nowhere > rbuf size */ MPI_Barrier(comm); start = MPI_Wtime(); for (i = 0; i < LOOPS; i++) { MPI_Allgatherv(SMPI_VARGET_GLOBAL(sbuf), SMPI_VARGET_GLOBAL(recvcounts)[comm_rank], MPI_CHAR, SMPI_VARGET_GLOBAL(rbuf), SMPI_VARGET_GLOBAL(recvcounts), SMPI_VARGET_GLOBAL(displs), MPI_CHAR, comm); } end = MPI_Wtime(); MPI_Barrier(comm); /* Convert to microseconds (why?) */ total_time = 1.0e6 * (end - start); MPI_Reduce(&total_time, &avg_time, 1, MPI_DOUBLE, MPI_SUM, 0, comm); MPI_Reduce(&total_time, max_time, 1, MPI_DOUBLE, MPI_MAX, 0, comm); return (avg_time / (LOOPS * comm_size)); } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/icscatter.c000644 001750 001750 00000004414 12342443661 022237 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple intercomm scatter test"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int *buf = 0; int leftGroup, i, count, rank, size, rsize; MPI_Comm comm; MPI_Datatype datatype; MTest_Init( &argc, &argv ); datatype = MPI_INT; /* Get an intercommunicator */ while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_remote_size( comm, &rsize ); MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN ); for (count = 1; count < 65000; count = 2 * count) { buf = 0; if (leftGroup) { buf = (int *)malloc( count * rsize * sizeof(int) ); if (rank == 0) { for (i=0; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_Reduce with non-commutative user-define operations"; */ /* * This tests that the reduce operation respects the noncommutative flag. * See red4.c for a version that can distinguish between P_{root} P_{root+1} * ... P_{root-1} and P_0 ... P_{size-1} . The MPI standard clearly * specifies that the result is P_0 ... P_{size-1}, independent of the root * (see 4.9.4 in MPI-1) */ /* This implements a simple matrix-matrix multiply. This is an associative but not commutative operation. The matrix size is set in matSize; the number of matrices is the count argument. The matrix is stored in C order, so that c(i,j) is cin[j+i*matSize] */ #define MAXCOL 256 static int matSize = 0; /* Must be < MAXCOL */ void uop( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype ); void uop( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype ) { const int *cin = (const int *)cinPtr; int *cout = (int *)coutPtr; int i, j, k, nmat; int tempCol[MAXCOL]; for (nmat = 0; nmat < *count; nmat++) { for (j=0; j #include /* Gather data from a vector to contiguous. Use IN_PLACE */ int main( int argc, char **argv ) { MPI_Datatype vec; double *vecin, *vecout; MPI_Comm comm; int count, minsize = 2; int root, i, n, stride, errs = 0; int rank, size; MTest_Init( &argc, &argv ); while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); for (root=0; root #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple intercomm allgather test"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int *rbuf = 0, *sbuf = 0; int leftGroup, i, count, rank, rsize; MPI_Comm comm; MPI_Datatype datatype; MTest_Init( &argc, &argv ); datatype = MPI_INT; /* Get an intercommunicator */ while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_rank( comm, &rank ); MPI_Comm_remote_size( comm, &rsize ); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Errhandler_set( comm, MPI_ERRORS_RETURN ); for (count = 1; count < 65000; count = 2 * count) { /* The left group will send rank to the right group; The right group will send -rank to the left group */ rbuf = (int *)malloc( count * rsize * sizeof(int) ); sbuf = (int *)malloc( count * sizeof(int) ); for (i=0; i #include "mpitest.h" #define BAD_ANSWER 100000 int assoc ( int *, int *, int *, MPI_Datatype * ); /* The operation is inoutvec[i] = invec[i] op inoutvec[i] (see 4.9.4). The order is important. Note that the computation is in process rank (in the communicator) order, independant of the root. */ int assoc(int *invec, int *inoutvec, int *len, MPI_Datatype *dtype) { int i; for ( i=0; i<*len; i++ ) { if (inoutvec[i] <= invec[i] ) { int rank; MPI_Comm_rank( MPI_COMM_WORLD, &rank ); fprintf( stderr, "[%d] inout[0] = %d, in[0] = %d\n", rank, inoutvec[0], invec[0] ); inoutvec[i] = BAD_ANSWER; } else inoutvec[i] = invec[i]; } return (1); } int main( int argc, char **argv ) { int rank, size; int data; int errors=0; int result = -100; MPI_Op op; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); data = rank; MPI_Op_create( (MPI_User_function*)assoc, 0, &op ); MPI_Reduce ( &data, &result, 1, MPI_INT, op, size-1, MPI_COMM_WORLD ); MPI_Bcast ( &result, 1, MPI_INT, size-1, MPI_COMM_WORLD ); MPI_Op_free( &op ); if (result == BAD_ANSWER) errors++; MTest_Finalize( errors ); MPI_Finalize(); return MTestReturnValue( errors ); } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/scatterv.c000644 001750 001750 00000013705 12342443661 022114 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include /* Prototypes for picky compilers */ void SetData ( double *, double *, int, int, int, int, int, int ); int CheckData ( double *, int, int, int, int, int, int ); /* This is an example of using scatterv to send a matrix from one process to all others, with the matrix stored in Fortran order. Note the use of an explicit UB to enable the sources to overlap. This tests scatterv to make sure that it uses the datatype size and extent correctly. It requires number of processors that can be split with MPI_Dims_create. */ void SetData( double *sendbuf, double *recvbuf, int nx, int ny, int myrow, int mycol, int nrow, int ncol ) { int coldim, i, j, m, k; double *p; if (myrow == 0 && mycol == 0) { coldim = nx * nrow; for (j=0; j #include #include "mpitest.h" /* USE_STRICT_MPI may be defined in mpitestconf.h */ #include "mpitestconf.h" #if !defined(USE_STRICT_MPI) && defined(MPICH) #define TEST_NBC_ROUTINES 1 #endif #define NUM_INTS (2) #define my_assert(cond_) \ do { \ if (!(cond_)) { \ fprintf(stderr, "assertion (%s) failed, aborting\n", #cond_); \ MPI_Abort(MPI_COMM_WORLD, 1); \ exit(1); \ } \ } while (0) int main(int argc, char **argv) { int errs = 0; int rank, size; int *sbuf = NULL; int *rbuf = NULL; int *scounts = NULL; int *rcounts = NULL; int *sdispls = NULL; int *rdispls = NULL; MPI_Comm comm; #if defined(TEST_NBC_ROUTINES) int i; int *types = NULL; MPI_Request req; #endif /* intentionally not using MTest_Init/MTest_Finalize in order to make it * easy to take this test and use it as an NBC sanity test outside of the * MPICH test suite */ MPI_Init(&argc, &argv); comm = MPI_COMM_WORLD; MPI_Comm_size(comm, &size); MPI_Comm_rank(comm, &rank); #if defined(TEST_NBC_ROUTINES) /* enough space for every process to contribute at least NUM_INTS ints to any * collective operation */ sbuf = malloc(NUM_INTS*size*sizeof(int)); my_assert(sbuf); rbuf = malloc(NUM_INTS*size*sizeof(int)); my_assert(rbuf); scounts = malloc(size*sizeof(int)); my_assert(scounts); rcounts = malloc(size*sizeof(int)); my_assert(rcounts); sdispls = malloc(size*sizeof(int)); my_assert(sdispls); rdispls = malloc(size*sizeof(int)); my_assert(rdispls); types = malloc(size*sizeof(int)); my_assert(types); for (i = 0; i < size; ++i) { sbuf[2*i] = i; sbuf[2*i+1] = i; rbuf[2*i] = i; rbuf[2*i+1] = i; scounts[i] = NUM_INTS; rcounts[i] = NUM_INTS; sdispls[i] = i * NUM_INTS; rdispls[i] = i * NUM_INTS; types[i] = MPI_INT; } MPI_Ibarrier(comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Ibcast(sbuf, NUM_INTS, MPI_INT, 0, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Igather(sbuf, NUM_INTS, MPI_INT, rbuf, NUM_INTS, MPI_INT, 0, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Igatherv(sbuf, NUM_INTS, MPI_INT, rbuf, rcounts, rdispls, MPI_INT, 0, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Iscatter(sbuf, NUM_INTS, MPI_INT, rbuf, NUM_INTS, MPI_INT, 0, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Iscatterv(sbuf, scounts, sdispls, MPI_INT, rbuf, NUM_INTS, MPI_INT, 0, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Iallgather(sbuf, NUM_INTS, MPI_INT, rbuf, NUM_INTS, MPI_INT, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Iallgatherv(sbuf, NUM_INTS, MPI_INT, rbuf, rcounts, rdispls, MPI_INT, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Ialltoall(sbuf, NUM_INTS, MPI_INT, rbuf, NUM_INTS, MPI_INT, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Ialltoallv(sbuf, scounts, sdispls, MPI_INT, rbuf, rcounts, rdispls, MPI_INT, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Ialltoallw(sbuf, scounts, sdispls, types, rbuf, rcounts, rdispls, types, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Ireduce(sbuf, rbuf, NUM_INTS, MPI_INT, MPI_SUM, 0, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Iallreduce(sbuf, rbuf, NUM_INTS, MPI_INT, MPI_SUM, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Ireduce_scatter(sbuf, rbuf, rcounts, MPI_INT, MPI_SUM, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Ireduce_scatter_block(sbuf, rbuf, NUM_INTS, MPI_INT, MPI_SUM, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Iscan(sbuf, rbuf, NUM_INTS, MPI_INT, MPI_SUM, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); MPI_Iexscan(sbuf, rbuf, NUM_INTS, MPI_INT, MPI_SUM, comm, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); #endif if (sbuf) free(sbuf); if (rbuf) free(rbuf); if (scounts) free(scounts); if (rcounts) free(rcounts); if (sdispls) free(sdispls); if (rdispls) free(rdispls); if (rank == 0) { if (errs) fprintf(stderr, "Found %d errors\n", errs); else printf(" No errors\n"); } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/alltoallv0.c000644 001750 001750 00000007064 12342443661 022334 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitest.h" #include #include /* This program tests MPI_Alltoallv by having processor each process send data to two neighbors only, using counts of 0 for the other processes. This idiom is sometimes used for halo exchange operations. Because there are separate send and receive types to alltoallv, there need to be tests to rearrange data on the fly. Not done yet. Currently, the test uses only MPI_INT; this is adequate for testing systems that use point-to-point operations */ int main( int argc, char **argv ) { MPI_Comm comm; int *sbuf, *rbuf; int rank, size; int *sendcounts, *recvcounts, *rdispls, *sdispls; int i, *p, err; int left, right, length; MTest_Init( &argc, &argv ); err = 0; while (MTestGetIntracommGeneral( &comm, 2, 1 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); if (size < 3) continue; /* Create and load the arguments to alltoallv */ sendcounts = (int *)malloc( size * sizeof(int) ); recvcounts = (int *)malloc( size * sizeof(int) ); rdispls = (int *)malloc( size * sizeof(int) ); sdispls = (int *)malloc( size * sizeof(int) ); if (!sendcounts || !recvcounts || !rdispls || !sdispls) { fprintf( stderr, "Could not allocate arg items!\n" ); MPI_Abort( comm, 1 ); exit(1); } /* Get the neighbors */ left = (rank - 1 + size) % size; right = (rank + 1) % size; /* Set the defaults */ for (i=0; i void addem ( int *, int *, int *, MPI_Datatype * ); void assoc ( int *, int *, int *, MPI_Datatype * ); void addem( int *invec, int *inoutvec, int *len, MPI_Datatype *dtype) { int i; for ( i=0; i<*len; i++ ) inoutvec[i] += invec[i]; } #define BAD_ANSWER 100000 /* The operation is inoutvec[i] = invec[i] op inoutvec[i] (see 4.9.4). The order is important. Note that the computation is in process rank (in the communicator) order, independant of the root. */ void assoc( int *invec, int *inoutvec, int *len, MPI_Datatype *dtype) { int i; for ( i=0; i<*len; i++ ) { if (inoutvec[i] <= invec[i] ) { int rank; MPI_Comm_rank( MPI_COMM_WORLD, &rank ); fprintf( stderr, "[%d] inout[0] = %d, in[0] = %d\n", rank, inoutvec[0], invec[0] ); inoutvec[i] = BAD_ANSWER; } else inoutvec[i] = invec[i]; } } int main( int argc, char **argv ) { int rank, size, i; int data; int errors=0; int result = -100; int correct_result; MPI_Op op_assoc, op_addem; MPI_Comm comm=MPI_COMM_WORLD; MPI_Init( &argc, &argv ); MPI_Op_create( (MPI_User_function *)assoc, 0, &op_assoc ); MPI_Op_create( (MPI_User_function *)addem, 1, &op_addem ); /* Run this for a variety of communicator sizes */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); data = rank; correct_result = 0; for (i=0;i<=rank;i++) correct_result += i; MPI_Scan ( &data, &result, 1, MPI_INT, MPI_SUM, comm ); if (result != correct_result) { fprintf( stderr, "[%d] Error suming ints with scan\n", rank ); errors++; } MPI_Scan ( &data, &result, 1, MPI_INT, MPI_SUM, comm ); if (result != correct_result) { fprintf( stderr, "[%d] Error summing ints with scan (2)\n", rank ); errors++; } data = rank; result = -100; MPI_Scan ( &data, &result, 1, MPI_INT, op_addem, comm ); if (result != correct_result) { fprintf( stderr, "[%d] Error summing ints with scan (userop)\n", rank ); errors++; } MPI_Scan ( &data, &result, 1, MPI_INT, op_addem, comm ); if (result != correct_result) { fprintf( stderr, "[%d] Error summing ints with scan (userop2)\n", rank ); errors++; } result = -100; data = rank; MPI_Scan ( &data, &result, 1, MPI_INT, op_assoc, comm ); if (result == BAD_ANSWER) { fprintf( stderr, "[%d] Error scanning with non-commutative op\n", rank ); errors++; } MPI_Op_free( &op_assoc ); MPI_Op_free( &op_addem ); MPI_Finalize(); if (errors) printf( "[%d] done with ERRORS(%d)!\n", rank, errors ); else { if (rank == 0) printf(" No Errors\n"); } return errors; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/coll7.c000644 001750 001750 00000003743 12342443661 021302 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" #define MAX_PROCESSES 10 int main( int argc, char **argv ) { int rank, size, i,j; int table[MAX_PROCESSES][MAX_PROCESSES]; int errors=0; int participants; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); /* A maximum of MAX_PROCESSES processes can participate */ if ( size > MAX_PROCESSES ) participants = MAX_PROCESSES; else participants = size; if (MAX_PROCESSES % participants) { fprintf( stderr, "Number of processors must divide %d\n", MAX_PROCESSES ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } /* while (MAX_PROCESSES % participants) participants--; */ if ( (rank < participants) ) { /* Determine what rows are my responsibility */ int block_size = MAX_PROCESSES / participants; int begin_row = rank * block_size; int end_row = (rank+1) * block_size; int send_count = block_size * MAX_PROCESSES; int recv_count = send_count; /* Paint my rows my color */ for (i=begin_row; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_Allreduce with apparent non-commutative operators"; */ /* While the operator is in fact commutative, this forces the MPI code to run the code that is used for non-commutative operators, and for various message lengths. Other tests check truly non-commutative operators */ void mysum( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype ); void mysum( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype ) { const int *cin = (const int *)cinPtr; int *cout = (int *)coutPtr; int i, n = *count; for (i=0; i #include "mpitest.h" #include /* static char MTEST_Descrip[] = ""; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size; int minsize = 2, count; MPI_Comm comm; int *sendbuf, *recvbuf, *p; int sendcount, recvcount; int i, j; MPI_Datatype sendtype, recvtype; MTest_Init( &argc, &argv ); /* The following illustrates the use of the routines to run through a selection of communicators and datatypes. Use subsets of these for tests that do not involve combinations of communicators, datatypes, and counts of datatypes */ while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); /* printf( "Size of comm = %d\n", size ); */ for (count = 1; count < 65000; count = count * 2) { /* Create a send buf and a receive buf suitable for testing all to all. */ sendcount = count; recvcount = count; sendbuf = (int *)malloc( count * size * sizeof(int) ); recvbuf = (int *)malloc( count * size * sizeof(int) ); sendtype = MPI_INT; recvtype = MPI_INT; if (!sendbuf || !recvbuf) { errs++; fprintf( stderr, "Failed to allocate sendbuf and/or recvbuf\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } for (i=0; i #include #include #include "mpitest.h" #define ROOT 0 #define NUM_REPS 5 #define NUM_SIZES 4 int main( int argc, char **argv) { int *buf; int i, rank, reps, n; int bVerify = 1; int sizes[NUM_SIZES] = { 100, 64*1024, 128*1024, 1024*1024 }; int num_errors=0; MTest_Init( &argc, &argv ); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (argc > 1) { if (strcmp(argv[1], "-novalidate") == 0 || strcmp(argv[1], "-noverify") == 0) bVerify = 0; } buf = (int *) malloc(sizes[NUM_SIZES-1]*sizeof(int)); memset(buf, 0, sizes[NUM_SIZES-1]*sizeof(int)); for (n=0; n= 10) { printf("Error: Rank=%d, num_errors = %d\n", rank, num_errors); fflush(stdout); } } } } free(buf); MTest_Finalize( num_errors ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/iallred.c000644 001750 001750 00000002145 12342443661 021671 0ustar00cici000000 000000 #include #include #include "mpi.h" #include "mpitest.h" /* Since MPICH is currently the only NBC implementation in existence, just use * this quick-and-dirty #ifdef to decide whether to test the nonblocking * collectives. Eventually we can add a configure option or configure test, or * the MPI-3 standard will be released and these can be gated on a MPI_VERSION * check */ #if !defined(USE_STRICT_MPI) && defined(MPICH) #define TEST_NBC_ROUTINES 1 #endif int main(int argc, char *argv[]) { int size, rank; #if defined(TEST_NBC_ROUTINES) MPI_Request request; int one = 1, two = 2, isum, sum; #endif MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); assert(size == 2); #if defined(TEST_NBC_ROUTINES) MPI_Iallreduce(&one,&isum,1,MPI_INT,MPI_SUM,MPI_COMM_WORLD,&request); MPI_Allreduce(&two,&sum,1,MPI_INT,MPI_SUM,MPI_COMM_WORLD); MPI_Wait(&request,MPI_STATUS_IGNORE); assert(isum == 2); assert(sum == 4); if (rank == 0) printf(" No errors\n"); #endif MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/redscat2.c000644 001750 001750 00000006442 12342443661 021770 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* * Test of reduce scatter. * * Checks that non-commutative operations are not commuted and that * all of the operations are performed. * * Can be called with any number of processors. */ #include "mpi.h" #include #include #include "mpitest.h" int err = 0; /* left(x,y) ==> x */ void left(void *a, void *b, int *count, MPI_Datatype *type); void left(void *a, void *b, int *count, MPI_Datatype *type) { int *in = a; int *inout = b; int i; for (i = 0; i < *count; ++i) { if (in[i] > inout[i]) ++err; inout[i] = in[i]; } } /* right(x,y) ==> y */ void right(void *a, void *b, int *count, MPI_Datatype *type); void right(void *a, void *b, int *count, MPI_Datatype *type) { int *in = a; int *inout = b; int i; for (i = 0; i < *count; ++i) { if (in[i] > inout[i]) ++err; inout[i] = inout[i]; } } /* Just performs a simple sum but can be marked as non-commutative to potentially tigger different logic in the implementation. */ void nc_sum(void *a, void *b, int *count, MPI_Datatype *type); void nc_sum(void *a, void *b, int *count, MPI_Datatype *type) { int *in = a; int *inout = b; int i; for (i = 0; i < *count; ++i) { inout[i] = in[i] + inout[i]; } } #define MAX_BLOCK_SIZE 256 int main( int argc, char **argv ) { int *sendbuf, *recvcounts; int block_size; int *recvbuf; int size, rank, i; MPI_Comm comm; MPI_Op left_op, right_op, nc_sum_op; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); MPI_Op_create(&left, 0/*non-commutative*/, &left_op); MPI_Op_create(&right, 0/*non-commutative*/, &right_op); MPI_Op_create(&nc_sum, 0/*non-commutative*/, &nc_sum_op); for (block_size = 1; block_size < MAX_BLOCK_SIZE; block_size *= 2) { sendbuf = (int *) malloc( block_size * size * sizeof(int) ); recvbuf = malloc( block_size * sizeof(int) ); for (i=0; i<(size*block_size); i++) sendbuf[i] = rank + i; for (i=0; i #include /* This program tests MPI_Alltoallw by having processor i send different amounts of data to each processor. This is just the MPI_Alltoallv test, but with displacements in bytes rather than units of the datatype. Because there are separate send and receive types to alltoallw, there need to be tests to rearrange data on the fly. Not done yet. The first test sends i items to processor i from all processors. Currently, the test uses only MPI_INT; this is adequate for testing systems that use point-to-point operations */ int main( int argc, char **argv ) { MPI_Comm comm; int *sbuf, *rbuf; int rank, size, lsize, asize; int *sendcounts, *recvcounts, *rdispls, *sdispls; int i, j, *p, err; MPI_Datatype *sendtypes, *recvtypes; int leftGroup; MTest_Init( &argc, &argv ); err = 0; while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; /* Create the buffer */ MPI_Comm_size( comm, &lsize ); MPI_Comm_remote_size( comm, &size ); asize = (lsize > size) ? lsize : size; MPI_Comm_rank( comm, &rank ); sbuf = (int *)malloc( size * size * sizeof(int) ); rbuf = (int *)malloc( asize * asize * sizeof(int) ); if (!sbuf || !rbuf) { fprintf( stderr, "Could not allocated buffers!\n" ); MPI_Abort( comm, 1 ); exit(1); } /* Load up the buffers */ for (i=0; i #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_SUM operations on optional datatypes dupported by MPICH"; */ typedef struct { double r, i; } d_complex; #ifdef HAVE_LONG_DOUBLE typedef struct { long double r, i; } ld_complex; #endif /* * This test looks at the handling of logical and for types that are not * integers or are not required integers (e.g., long long). MPICH allows * these as well. A strict MPI test should not include this test. */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size; MPI_Comm comm; char cinbuf[3], coutbuf[3]; signed char scinbuf[3], scoutbuf[3]; unsigned char ucinbuf[3], ucoutbuf[3]; d_complex dinbuf[3], doutbuf[3]; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); #ifndef USE_STRICT_MPI /* char */ MTestPrintfMsg( 10, "Reduce of MPI_CHAR\n" ); cinbuf[0] = 1; cinbuf[1] = 0; cinbuf[2] = (rank > 0); coutbuf[0] = 0; coutbuf[1] = 1; coutbuf[2] = 1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_CHAR, MPI_SUM, 0, comm ); if (rank == 0) { if (size < 128 && coutbuf[0] != size) { errs++; fprintf( stderr, "char SUM(1) test failed\n" ); } if (size < 128 && coutbuf[1] != 0) { errs++; fprintf( stderr, "char SUM(0) test failed\n" ); } if (size < 128 && coutbuf[2] != size - 1) { errs++; fprintf( stderr, "char SUM(>) test failed\n" ); } } #endif /* USE_MPI_STRICT */ /* signed char */ MTestPrintfMsg( 10, "Reduce of MPI_SIGNED_CHAR\n" ); scinbuf[0] = 1; scinbuf[1] = 0; scinbuf[2] = (rank > 0); scoutbuf[0] = 0; scoutbuf[1] = 1; scoutbuf[2] = 1; MPI_Reduce( scinbuf, scoutbuf, 3, MPI_SIGNED_CHAR, MPI_SUM, 0, comm ); if (rank == 0) { if (size < 128 && scoutbuf[0] != size) { errs++; fprintf( stderr, "signed char SUM(1) test failed\n" ); } if (size < 128 && scoutbuf[1] != 0) { errs++; fprintf( stderr, "signed char SUM(0) test failed\n" ); } if (size < 128 && scoutbuf[2] != size - 1) { errs++; fprintf( stderr, "signed char SUM(>) test failed\n" ); } } /* unsigned char */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_CHAR\n" ); ucinbuf[0] = 1; ucinbuf[1] = 0; ucinbuf[2] = (rank > 0); ucoutbuf[0] = 0; ucoutbuf[1] = 1; ucoutbuf[2] = 1; MPI_Reduce( ucinbuf, ucoutbuf, 3, MPI_UNSIGNED_CHAR, MPI_SUM, 0, comm ); if (rank == 0) { if (size < 128 && ucoutbuf[0] != size) { errs++; fprintf( stderr, "unsigned char SUM(1) test failed\n" ); } if (size < 128 && ucoutbuf[1]) { errs++; fprintf( stderr, "unsigned char SUM(0) test failed\n" ); } if (size < 128 && ucoutbuf[2] != size - 1) { errs++; fprintf( stderr, "unsigned char SUM(>) test failed\n" ); } } #ifndef USE_STRICT_MPI /* For some reason, complex is not allowed for sum and prod */ if (MPI_DOUBLE_COMPLEX != MPI_DATATYPE_NULL) { int dc; #ifdef HAVE_LONG_DOUBLE ld_complex ldinbuf[3], ldoutbuf[3]; #endif /* Must determine which C type matches this Fortran type */ MPI_Type_size( MPI_DOUBLE_COMPLEX, &dc ); if (dc == sizeof(d_complex)) { MTestPrintfMsg( 10, "Reduce of MPI_DOUBLE_COMPLEX\n" ); /* double complex; may be null if we do not have Fortran support */ dinbuf[0].r = 1; dinbuf[1].r = 0; dinbuf[2].r = (rank > 0); dinbuf[0].i = -1; dinbuf[1].i = 0; dinbuf[2].i = -(rank > 0); doutbuf[0].r = 0; doutbuf[1].r = 1; doutbuf[2].r = 1; doutbuf[0].i = 0; doutbuf[1].i = 1; doutbuf[2].i = 1; MPI_Reduce( dinbuf, doutbuf, 3, MPI_DOUBLE_COMPLEX, MPI_SUM, 0, comm ); if (rank == 0) { if (doutbuf[0].r != size || doutbuf[0].i != -size) { errs++; fprintf( stderr, "double complex SUM(1) test failed\n" ); } if (doutbuf[1].r != 0 || doutbuf[1].i != 0) { errs++; fprintf( stderr, "double complex SUM(0) test failed\n" ); } if (doutbuf[2].r != size - 1 || doutbuf[2].i != 1 - size) { errs++; fprintf( stderr, "double complex SUM(>) test failed\n" ); } } } #ifdef HAVE_LONG_DOUBLE else if (dc == sizeof(ld_complex)) { MTestPrintfMsg( 10, "Reduce of MPI_DOUBLE_COMPLEX\n" ); /* double complex; may be null if we do not have Fortran support */ ldinbuf[0].r = 1; ldinbuf[1].r = 0; ldinbuf[2].r = (rank > 0); ldinbuf[0].i = -1; ldinbuf[1].i = 0; ldinbuf[2].i = -(rank > 0); ldoutbuf[0].r = 0; ldoutbuf[1].r = 1; ldoutbuf[2].r = 1; ldoutbuf[0].i = 0; ldoutbuf[1].i = 1; ldoutbuf[2].i = 1; MPI_Reduce( ldinbuf, ldoutbuf, 3, MPI_DOUBLE_COMPLEX, MPI_SUM, 0, comm ); if (rank == 0) { if (ldoutbuf[0].r != size || ldoutbuf[0].i != -size) { errs++; fprintf( stderr, "double complex SUM(1) test failed\n" ); } if (ldoutbuf[1].r != 0 || ldoutbuf[1].i != 0) { errs++; fprintf( stderr, "double complex SUM(0) test failed\n" ); } if (ldoutbuf[2].r != size - 1 || ldoutbuf[2].i != 1 - size) { errs++; fprintf( stderr, "double complex SUM(>) test failed\n" ); } } } #endif /* Implicitly ignore if there is no matching C type */ } #endif /* USE_STRICT_MPI */ #ifdef HAVE_LONG_DOUBLE { long double ldinbuf[3], ldoutbuf[3]; /* long double */ ldinbuf[0] = 1; ldinbuf[1] = 0; ldinbuf[2] = (rank > 0); ldoutbuf[0] = 0; ldoutbuf[1] = 1; ldoutbuf[2] = 1; if (MPI_LONG_DOUBLE != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_DOUBLE\n" ); MPI_Reduce( ldinbuf, ldoutbuf, 3, MPI_LONG_DOUBLE, MPI_SUM, 0, comm ); if (rank == 0) { if (ldoutbuf[0] != size) { errs++; fprintf( stderr, "long double SUM(1) test failed\n" ); } if (ldoutbuf[1] != 0.0) { errs++; fprintf( stderr, "long double SUM(0) test failed\n" ); } if (ldoutbuf[2] != size - 1) { errs++; fprintf( stderr, "long double SUM(>) test failed\n" ); } } } } #endif #ifdef HAVE_LONG_LONG { long long llinbuf[3], lloutbuf[3]; /* long long */ llinbuf[0] = 1; llinbuf[1] = 0; llinbuf[2] = (rank > 0); lloutbuf[0] = 0; lloutbuf[1] = 1; lloutbuf[2] = 1; if (MPI_LONG_LONG != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_LONG\n" ); MPI_Reduce( llinbuf, lloutbuf, 3, MPI_LONG_LONG, MPI_SUM, 0, comm ); if (rank == 0) { if (lloutbuf[0] != size) { errs++; fprintf( stderr, "long long SUM(1) test failed\n" ); } if (lloutbuf[1] != 0) { errs++; fprintf( stderr, "long long SUM(0) test failed\n" ); } if (lloutbuf[2] != size - 1) { errs++; fprintf( stderr, "long long SUM(>) test failed\n" ); } } } } #endif MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/redscat.c000644 001750 001750 00000002660 12342443661 021704 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* * Test of reduce scatter. * * Each processor contributes its rank + the index to the reduction, * then receives the ith sum * * Can be called with any number of processors. */ #include "mpi.h" #include #include int main( int argc, char **argv ) { int err = 0, toterr; int *sendbuf, recvbuf, *recvcounts; int size, rank, i, sumval; MPI_Comm comm; MPI_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); sendbuf = (int *) malloc( size * sizeof(int) ); for (i=0; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "A simple test of Reduce with all choices of root process"; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size, root; int *sendbuf, *recvbuf, i; int minsize = 2, count; MPI_Comm comm; MTest_Init( &argc, &argv ); while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); for (count = 1; count < 130000; count = count * 2) { sendbuf = (int *)malloc( count * sizeof(int) ); recvbuf = (int *)malloc( count * sizeof(int) ); for (root = 0; root < size; root ++) { for (i=0; i #include /* Gather data from a vector to contiguous. This is the trivial version based on the allgather test (allgatherv but with constant data sizes) */ int main( int argc, char **argv ) { double *vecout, *invec; MPI_Comm comm; int count, minsize = 2; int i, errs = 0; int rank, size; int *displs, *recvcounts; MTest_Init( &argc, &argv ); while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); displs = (int *)malloc( size * sizeof(int) ); recvcounts = (int *)malloc( size * sizeof(int) ); for (count = 1; count < 9000; count = count * 2) { invec = (double *)malloc( count * sizeof(double) ); vecout = (double *)malloc( size * count * sizeof(double) ); for (i=0; i #include /* Gather data from a vector to contiguous. Use IN_PLACE */ int main( int argc, char **argv ) { MPI_Datatype vec; double *vecin, *vecout; MPI_Comm comm; int count, minsize = 2; int root, i, n, stride, errs = 0; int rank, size; MTest_Init( &argc, &argv ); while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); for (root=0; root #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple intercomm broadcast test"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int *buf = 0; int leftGroup, i, count, rank; MPI_Comm comm; MPI_Datatype datatype; MTest_Init( &argc, &argv ); datatype = MPI_INT; /* Get an intercommunicator */ while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_rank( comm, &rank ); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN ); for (count = 1; count < 65000; count = 2 * count) { buf = (int *)malloc( count * sizeof(int) ); if (leftGroup) { if (rank == 0) { for (i=0; i #include /* This program tests MPI_Alltoallv by having processor i send different amounts of data to each processor. Because there are separate send and receive types to alltoallv, there need to be tests to rearrange data on the fly. Not done yet. The first test sends i items to processor i from all processors. Currently, the test uses only MPI_INT; this is adequate for testing systems that use point-to-point operations */ int main( int argc, char **argv ) { MPI_Comm comm; int *sbuf, *rbuf; int rank, size, lsize, asize; int *sendcounts, *recvcounts, *rdispls, *sdispls; int i, j, *p, err; int leftGroup; MTest_Init( &argc, &argv ); err = 0; while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; /* Create the buffer */ MPI_Comm_size( comm, &lsize ); MPI_Comm_remote_size( comm, &size ); asize = (lsize > size) ? lsize : size; MPI_Comm_rank( comm, &rank ); sbuf = (int *)malloc( size * size * sizeof(int) ); rbuf = (int *)malloc( asize * asize * sizeof(int) ); if (!sbuf || !rbuf) { fprintf( stderr, "Could not allocated buffers!\n" ); MPI_Abort( comm, 1 ); exit(1); } /* Load up the buffers */ for (i=0; i #include "mpitest.h" #define MAX_PROCESSES 10 int main( int argc, char **argv ) { int rank, size, i,j; int table[MAX_PROCESSES][MAX_PROCESSES]; int errors=0; int participants; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); /* A maximum of MAX_PROCESSES processes can participate */ if ( size > MAX_PROCESSES ) participants = MAX_PROCESSES; else participants = size; if (MAX_PROCESSES % participants) { fprintf( stderr, "Number of processors must divide %d\n", MAX_PROCESSES ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } if ( (rank < participants) ) { /* Determine what rows are my responsibility */ int block_size = MAX_PROCESSES / participants; int begin_row = rank * block_size; int end_row = (rank+1) * block_size; int send_count = block_size * MAX_PROCESSES; int recv_count = send_count; /* Paint my rows my color */ for (i=begin_row; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_Reduce with non-commutative user-define operations and arbitrary root"; */ /* * This tests that the reduce operation respects the noncommutative flag. * and that can distinguish between P_{root} P_{root+1} * ... P_{root-1} and P_0 ... P_{size-1} . The MPI standard clearly * specifies that the result is P_0 ... P_{size-1}, independent of the root * (see 4.9.4 in MPI-1) */ /* This implements a simple matrix-matrix multiply. This is an associative but not commutative operation. The matrix size is set in matSize; the number of matrices is the count argument. The matrix is stored in C order, so that c(i,j) is cin[j+i*matSize] */ #define MAXCOL 256 static int matSize = 0; /* Must be < MAXCOL */ void uop( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype ); void uop( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype ) { const int *cin; int *cout; int i, j, k, nmat; int tempCol[MAXCOL]; if (*count != 1) printf( "Panic!\n" ); for (nmat = 0; nmat < *count; nmat++) { cin = (const int *)cinPtr; cout = (int *)coutPtr; for (j=0; j MAXCOL) { /* Skip because there are too many processes */ MTestFreeComm( &comm ); continue; } /* Only one matrix for now */ count = 1; /* A single matrix, the size of the communicator */ MPI_Type_contiguous( size*size, MPI_INT, &mattype ); MPI_Type_commit( &mattype ); buf = (int *)malloc( count * size * size * sizeof(int) ); if (!buf) { MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } bufout = (int *)malloc( count * size * size * sizeof(int) ); if (!bufout) { MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } for (root = 0; root < size; root ++) { initMat( comm, buf ); MPI_Reduce( buf, bufout, count, mattype, op, root, comm ); if (rank == root) { errs += isPermutedIdentity( comm, bufout ); } /* Try the same test, but using MPI_IN_PLACE */ initMat( comm, bufout ); if (rank == root) { MPI_Reduce( MPI_IN_PLACE, bufout, count, mattype, op, root, comm ); } else { MPI_Reduce( bufout, NULL, count, mattype, op, root, comm ); } if (rank == root) { errs += isPermutedIdentity( comm, bufout ); } } MPI_Type_free( &mattype ); free( buf ); free( bufout ); MTestFreeComm( &comm ); } MPI_Op_free( &op ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/opband.c000644 001750 001750 00000021741 12342443661 021523 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitestconf.h" #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_BAND operations on optional datatypes dupported by MPICH"; */ /* * This test looks at the handling of logical and for types that are not * integers or are not required integers (e.g., long long). MPICH allows * these as well. A strict MPI test should not include this test. */ int main( int argc, char *argv[] ) { int errs = 0; int rc; int rank, size; MPI_Comm comm; char cinbuf[3], coutbuf[3]; signed char scinbuf[3], scoutbuf[3]; unsigned char ucinbuf[3], ucoutbuf[3]; short sinbuf[3], soutbuf[3]; unsigned short usinbuf[3], usoutbuf[3]; long linbuf[3], loutbuf[3]; unsigned long ulinbuf[3], uloutbuf[3]; unsigned uinbuf[3], uoutbuf[3]; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; /* Set errors return so that we can provide better information should a routine reject one of the operand/datatype pairs */ MPI_Errhandler_set( comm, MPI_ERRORS_RETURN ); MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); #ifndef USE_STRICT_MPI /* char */ MTestPrintfMsg( 10, "Reduce of MPI_CHAR\n" ); cinbuf[0] = 0xff; cinbuf[1] = 0; cinbuf[2] = (rank > 0) ? 0xff : 0xf0; coutbuf[0] = 0; coutbuf[1] = 1; coutbuf[2] = 1; rc = MPI_Reduce( cinbuf, coutbuf, 3, MPI_CHAR, MPI_BAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BAND and MPI_CHAR", rc ); errs++; } else { if (rank == 0) { if (coutbuf[0] != (char)0xff) { errs++; fprintf( stderr, "char BAND(1) test failed\n" ); } if (coutbuf[1]) { errs++; fprintf( stderr, "char BAND(0) test failed\n" ); } if (coutbuf[2] != (char)0xf0 && size > 1) { errs++; fprintf( stderr, "char BAND(>) test failed\n" ); } } } #endif /* USE_STRICT_MPI */ /* signed char */ MTestPrintfMsg( 10, "Reduce of MPI_SIGNED_CHAR\n" ); scinbuf[0] = 0xff; scinbuf[1] = 0; scinbuf[2] = (rank > 0) ? 0xff : 0xf0; scoutbuf[0] = 0; scoutbuf[1] = 1; scoutbuf[2] = 1; rc = MPI_Reduce( scinbuf, scoutbuf, 3, MPI_SIGNED_CHAR, MPI_BAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BAND and MPI_SIGNED_CHAR", rc ); errs++; } else { if (rank == 0) { if (scoutbuf[0] != (signed char)0xff) { errs++; fprintf( stderr, "signed char BAND(1) test failed\n" ); } if (scoutbuf[1]) { errs++; fprintf( stderr, "signed char BAND(0) test failed\n" ); } if (scoutbuf[2] != (signed char)0xf0 && size > 1) { errs++; fprintf( stderr, "signed char BAND(>) test failed\n" ); } } } /* unsigned char */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_CHAR\n" ); ucinbuf[0] = 0xff; ucinbuf[1] = 0; ucinbuf[2] = (rank > 0) ? 0xff : 0xf0; ucoutbuf[0] = 0; ucoutbuf[1] = 1; ucoutbuf[2] = 1; rc = MPI_Reduce( ucinbuf, ucoutbuf, 3, MPI_UNSIGNED_CHAR, MPI_BAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BAND and MPI_UNSIGNED_CHAR", rc ); errs++; } else { if (rank == 0) { if (ucoutbuf[0] != 0xff) { errs++; fprintf( stderr, "unsigned char BAND(1) test failed\n" ); } if (ucoutbuf[1]) { errs++; fprintf( stderr, "unsigned char BAND(0) test failed\n" ); } if (ucoutbuf[2] != 0xf0 && size > 1) { errs++; fprintf( stderr, "unsigned char BAND(>) test failed\n" ); } } } /* bytes */ MTestPrintfMsg( 10, "Reduce of MPI_BYTE\n" ); cinbuf[0] = 0xff; cinbuf[1] = 0; cinbuf[2] = (rank > 0) ? 0xff : 0xf0; coutbuf[0] = 0; coutbuf[1] = 1; coutbuf[2] = 1; rc = MPI_Reduce( cinbuf, coutbuf, 3, MPI_BYTE, MPI_BAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BAND and MPI_BYTE", rc ); errs++; } else { if (rank == 0) { if (coutbuf[0] != (char)0xff) { errs++; fprintf( stderr, "byte BAND(1) test failed\n" ); } if (coutbuf[1]) { errs++; fprintf( stderr, "byte BAND(0) test failed\n" ); } if (coutbuf[2] != (char)0xf0 && size > 1) { errs++; fprintf( stderr, "byte BAND(>) test failed\n" ); } } } /* short */ MTestPrintfMsg( 10, "Reduce of MPI_SHORT\n" ); sinbuf[0] = 0xffff; sinbuf[1] = 0; sinbuf[2] = (rank > 0) ? 0xffff : 0xf0f0; soutbuf[0] = 0; soutbuf[1] = 1; soutbuf[2] = 1; rc = MPI_Reduce( sinbuf, soutbuf, 3, MPI_SHORT, MPI_BAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BAND and MPI_SHORT", rc ); errs++; } else { if (rank == 0) { if (soutbuf[0] != (short)0xffff) { errs++; fprintf( stderr, "short BAND(1) test failed\n" ); } if (soutbuf[1]) { errs++; fprintf( stderr, "short BAND(0) test failed\n" ); } if (soutbuf[2] != (short)0xf0f0 && size > 1) { errs++; fprintf( stderr, "short BAND(>) test failed\n" ); } } } MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_SHORT\n" ); /* unsigned short */ usinbuf[0] = 0xffff; usinbuf[1] = 0; usinbuf[2] = (rank > 0) ? 0xffff : 0xf0f0; usoutbuf[0] = 0; usoutbuf[1] = 1; usoutbuf[2] = 1; rc = MPI_Reduce( usinbuf, usoutbuf, 3, MPI_UNSIGNED_SHORT, MPI_BAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BAND and MPI_UNSIGNED_SHORT", rc ); errs++; } else { if (rank == 0) { if (usoutbuf[0] != 0xffff) { errs++; fprintf( stderr, "short BAND(1) test failed\n" ); } if (usoutbuf[1]) { errs++; fprintf( stderr, "short BAND(0) test failed\n" ); } if (usoutbuf[2] != 0xf0f0 && size > 1) { errs++; fprintf( stderr, "short BAND(>) test failed\n" ); } } } /* unsigned */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED\n" ); uinbuf[0] = 0xffffffff; uinbuf[1] = 0; uinbuf[2] = (rank > 0) ? 0xffffffff : 0xf0f0f0f0; uoutbuf[0] = 0; uoutbuf[1] = 1; uoutbuf[2] = 1; rc = MPI_Reduce( uinbuf, uoutbuf, 3, MPI_UNSIGNED, MPI_BAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BAND and MPI_UNSIGNED", rc ); errs++; } else { if (rank == 0) { if (uoutbuf[0] != 0xffffffff) { errs++; fprintf( stderr, "unsigned BAND(1) test failed\n" ); } if (uoutbuf[1]) { errs++; fprintf( stderr, "unsigned BAND(0) test failed\n" ); } if (uoutbuf[2] != 0xf0f0f0f0 && size > 1) { errs++; fprintf( stderr, "unsigned BAND(>) test failed\n" ); } } } /* long */ MTestPrintfMsg( 10, "Reduce of MPI_LONG\n" ); linbuf[0] = 0xffffffff; linbuf[1] = 0; linbuf[2] = (rank > 0) ? 0xffffffff : 0xf0f0f0f0; loutbuf[0] = 0; loutbuf[1] = 1; loutbuf[2] = 1; rc = MPI_Reduce( linbuf, loutbuf, 3, MPI_LONG, MPI_BAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BAND and MPI_LONG", rc ); errs++; } else { if (rank == 0) { if (loutbuf[0] != 0xffffffff) { errs++; fprintf( stderr, "long BAND(1) test failed\n" ); } if (loutbuf[1]) { errs++; fprintf( stderr, "long BAND(0) test failed\n" ); } if (loutbuf[2] != 0xf0f0f0f0 && size > 1) { errs++; fprintf( stderr, "long BAND(>) test failed\n" ); } } } MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_LONG\n" ); /* unsigned long */ ulinbuf[0] = 0xffffffff; ulinbuf[1] = 0; ulinbuf[2] = (rank > 0) ? 0xffffffff : 0xf0f0f0f0; uloutbuf[0] = 0; uloutbuf[1] = 1; uloutbuf[2] = 1; rc = MPI_Reduce( ulinbuf, uloutbuf, 3, MPI_UNSIGNED_LONG, MPI_BAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BAND and MPI_UNSIGNED_LONG", rc ); errs++; } else { if (rank == 0) { if (uloutbuf[0] != 0xffffffff) { errs++; fprintf( stderr, "unsigned long BAND(1) test failed\n" ); } if (uloutbuf[1]) { errs++; fprintf( stderr, "unsigned long BAND(0) test failed\n" ); } if (uloutbuf[2] != 0xf0f0f0f0 && size > 1) { errs++; fprintf( stderr, "unsigned long BAND(>) test failed\n" ); } } } #ifdef HAVE_LONG_LONG { long long llinbuf[3], lloutbuf[3]; /* long long */ llinbuf[0] = 0xffffffff; llinbuf[1] = 0; llinbuf[2] = (rank > 0) ? 0xffffffff : 0xf0f0f0f0; lloutbuf[0] = 0; lloutbuf[1] = 1; lloutbuf[2] = 1; if (MPI_LONG_LONG != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_LONG\n" ); rc = MPI_Reduce( llinbuf, lloutbuf, 3, MPI_LONG_LONG, MPI_BAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BAND and MPI_LONG_LONG", rc ); errs++; } else { if (rank == 0) { if (lloutbuf[0] != 0xffffffff) { errs++; fprintf( stderr, "long long BAND(1) test failed\n" ); } if (lloutbuf[1]) { errs++; fprintf( stderr, "long long BAND(0) test failed\n" ); } if (lloutbuf[2] != 0xf0f0f0f0 && size > 1) { errs++; fprintf( stderr, "long long BAND(>) test failed\n" ); } } } } } #endif MPI_Errhandler_set( comm, MPI_ERRORS_ARE_FATAL ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/icgather.c000644 001750 001750 00000003750 12342443661 022046 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple intercomm gather test"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int *buf = 0; int leftGroup, i, count, rank, rsize, size; MPI_Comm comm; MPI_Datatype datatype; MTest_Init( &argc, &argv ); datatype = MPI_INT; /* Get an intercommunicator */ while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_rank( comm, &rank ); MPI_Comm_remote_size( comm, &rsize ); MPI_Comm_size( comm, &size ); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN ); for (count = 1; count < 65000; count = 2 * count) { if (leftGroup) { buf = (int *)malloc( count * rsize * sizeof(int) ); for (i=0; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_Exscan"; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size; int minsize = 2, count; int *sendbuf, *recvbuf, i; MPI_Comm comm; MTest_Init( &argc, &argv ); /* The following illustrates the use of the routines to run through a selection of communicators and datatypes. Use subsets of these for tests that do not involve combinations of communicators, datatypes, and counts of datatypes */ while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); for (count = 1; count < 65000; count = count * 2) { sendbuf = (int *)malloc( count * sizeof(int) ); recvbuf = (int *)malloc( count * sizeof(int) ); for (i=0; i 0) { int result; for (i=0; i #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_MAX operations on optional datatypes dupported by MPICH"; */ /* * This test looks at the handling of char and types that are not required * integers (e.g., long long). MPICH allows * these as well. A strict MPI test should not include this test. */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size; MPI_Comm comm; char cinbuf[3], coutbuf[3]; signed char scinbuf[3], scoutbuf[3]; unsigned char ucinbuf[3], ucoutbuf[3]; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); #ifndef USE_STRICT_MPI /* char */ MTestPrintfMsg( 10, "Reduce of MPI_CHAR\n" ); cinbuf[0] = 1; cinbuf[1] = 0; cinbuf[2] = rank; coutbuf[0] = 0; coutbuf[1] = 1; coutbuf[2] = 1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_CHAR, MPI_MAX, 0, comm ); if (rank == 0) { if (coutbuf[0] != 1) { errs++; fprintf( stderr, "char MAX(1) test failed\n" ); } if (coutbuf[1] != 0) { errs++; fprintf( stderr, "char MAX(0) test failed\n" ); } if (size < 128 && coutbuf[2] != size - 1) { errs++; fprintf( stderr, "char MAX(>) test failed\n" ); } } #endif /* USE_STRICT_MPI */ /* signed char */ MTestPrintfMsg( 10, "Reduce of MPI_SIGNED_CHAR\n" ); scinbuf[0] = 1; scinbuf[1] = 0; scinbuf[2] = rank; scoutbuf[0] = 0; scoutbuf[1] = 1; scoutbuf[2] = 1; MPI_Reduce( scinbuf, scoutbuf, 3, MPI_SIGNED_CHAR, MPI_MAX, 0, comm ); if (rank == 0) { if (scoutbuf[0] != 1) { errs++; fprintf( stderr, "signed char MAX(1) test failed\n" ); } if (scoutbuf[1] != 0) { errs++; fprintf( stderr, "signed char MAX(0) test failed\n" ); } if (size < 128 && scoutbuf[2] != size - 1) { errs++; fprintf( stderr, "signed char MAX(>) test failed\n" ); } } /* unsigned char */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_CHAR\n" ); ucinbuf[0] = 1; ucinbuf[1] = 0; ucinbuf[2] = rank; ucoutbuf[0] = 0; ucoutbuf[1] = 1; ucoutbuf[2] = 1; MPI_Reduce( ucinbuf, ucoutbuf, 3, MPI_UNSIGNED_CHAR, MPI_MAX, 0, comm ); if (rank == 0) { if (ucoutbuf[0] != 1) { errs++; fprintf( stderr, "unsigned char MAX(1) test failed\n" ); } if (ucoutbuf[1]) { errs++; fprintf( stderr, "unsigned char MAX(0) test failed\n" ); } if (size < 256 && ucoutbuf[2] != size - 1) { errs++; fprintf( stderr, "unsigned char MAX(>) test failed\n" ); } } #ifdef HAVE_LONG_DOUBLE { long double ldinbuf[3], ldoutbuf[3]; /* long double */ ldinbuf[0] = 1; ldinbuf[1] = 0; ldinbuf[2] = rank; ldoutbuf[0] = 0; ldoutbuf[1] = 1; ldoutbuf[2] = 1; if (MPI_LONG_DOUBLE != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_DOUBLE\n" ); MPI_Reduce( ldinbuf, ldoutbuf, 3, MPI_LONG_DOUBLE, MPI_MAX, 0, comm ); if (rank == 0) { if (ldoutbuf[0] != 1) { errs++; fprintf( stderr, "long double MAX(1) test failed\n" ); } if (ldoutbuf[1] != 0.0) { errs++; fprintf( stderr, "long double MAX(0) test failed\n" ); } if (ldoutbuf[2] != size - 1) { errs++; fprintf( stderr, "long double MAX(>) test failed\n" ); } } } } #endif /* HAVE_LONG_DOUBLE */ #ifdef HAVE_LONG_LONG { long long llinbuf[3], lloutbuf[3]; /* long long */ llinbuf[0] = 1; llinbuf[1] = 0; llinbuf[2] = rank; lloutbuf[0] = 0; lloutbuf[1] = 1; lloutbuf[2] = 1; if (MPI_LONG_LONG != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_LONG\n" ); MPI_Reduce( llinbuf, lloutbuf, 3, MPI_LONG_LONG, MPI_MAX, 0, comm ); if (rank == 0) { if (lloutbuf[0] != 1) { errs++; fprintf( stderr, "long long MAX(1) test failed\n" ); } if (lloutbuf[1] != 0) { errs++; fprintf( stderr, "long long MAX(0) test failed\n" ); } if (lloutbuf[2] != size - 1) { errs++; fprintf( stderr, "long long MAX(>) test failed\n" ); } } } } #endif /* HAVE_LONG_LONG */ MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/opland.c000644 001750 001750 00000014753 12342443661 021542 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitestconf.h" #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_LAND operations on optional datatypes dupported by MPICH"; */ /* * This test looks at the handling of logical and for types that are not * integers or are not required integers (e.g., long long). MPICH allows * these as well. A strict MPI test should not include this test. */ int main( int argc, char *argv[] ) { int errs = 0; int rc; int rank, size; MPI_Comm comm; char cinbuf[3], coutbuf[3]; signed char scinbuf[3], scoutbuf[3]; unsigned char ucinbuf[3], ucoutbuf[3]; float finbuf[3], foutbuf[3]; double dinbuf[3], doutbuf[3]; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; /* Set errors return so that we can provide better information should a routine reject one of the operand/datatype pairs */ MPI_Errhandler_set( comm, MPI_ERRORS_RETURN ); MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); #ifndef USE_STRICT_MPI /* char */ MTestPrintfMsg( 10, "Reduce of MPI_CHAR\n" ); cinbuf[0] = 1; cinbuf[1] = 0; cinbuf[2] = (rank > 0); coutbuf[0] = 0; coutbuf[1] = 1; coutbuf[2] = 1; rc = MPI_Reduce( cinbuf, coutbuf, 3, MPI_CHAR, MPI_LAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LAND and MPI_CHAR", rc ); errs++; } else { if (rank == 0) { if (!coutbuf[0]) { errs++; fprintf( stderr, "char AND(1) test failed\n" ); } if (coutbuf[1]) { errs++; fprintf( stderr, "char AND(0) test failed\n" ); } if (coutbuf[2] && size > 1) { errs++; fprintf( stderr, "char AND(>) test failed\n" ); } } } #endif /* USE_STRICT_MPI */ /* signed char */ MTestPrintfMsg( 10, "Reduce of MPI_SIGNED_CHAR\n" ); scinbuf[0] = 1; scinbuf[1] = 0; scinbuf[2] = (rank > 0); scoutbuf[0] = 0; scoutbuf[1] = 1; scoutbuf[2] = 1; rc = MPI_Reduce( scinbuf, scoutbuf, 3, MPI_SIGNED_CHAR, MPI_LAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LAND and MPI_SIGNED_CHAR", rc ); errs++; } else { if (rank == 0) { if (!scoutbuf[0]) { errs++; fprintf( stderr, "signed char AND(1) test failed\n" ); } if (scoutbuf[1]) { errs++; fprintf( stderr, "signed char AND(0) test failed\n" ); } if (scoutbuf[2] && size > 1) { errs++; fprintf( stderr, "signed char AND(>) test failed\n" ); } } } /* unsigned char */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_CHAR\n" ); ucinbuf[0] = 1; ucinbuf[1] = 0; ucinbuf[2] = (rank > 0); ucoutbuf[0] = 0; ucoutbuf[1] = 1; ucoutbuf[2] = 1; rc = MPI_Reduce( ucinbuf, ucoutbuf, 3, MPI_UNSIGNED_CHAR, MPI_LAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LAND and MPI_UNSIGNED_CHAR", rc ); errs++; } else { if (rank == 0) { if (!ucoutbuf[0]) { errs++; fprintf( stderr, "unsigned char AND(1) test failed\n" ); } if (ucoutbuf[1]) { errs++; fprintf( stderr, "unsigned char AND(0) test failed\n" ); } if (ucoutbuf[2] && size > 1) { errs++; fprintf( stderr, "unsigned char AND(>) test failed\n" ); } } } #ifndef USE_STRICT_MPI /* float */ MTestPrintfMsg( 10, "Reduce of MPI_FLOAT\n" ); finbuf[0] = 1; finbuf[1] = 0; finbuf[2] = (rank > 0); foutbuf[0] = 0; foutbuf[1] = 1; foutbuf[2] = 1; rc = MPI_Reduce( finbuf, foutbuf, 3, MPI_FLOAT, MPI_LAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LAND and MPI_FLOAT", rc ); errs++; } else { if (rank == 0) { if (!foutbuf[0]) { errs++; fprintf( stderr, "float AND(1) test failed\n" ); } if (foutbuf[1]) { errs++; fprintf( stderr, "float AND(0) test failed\n" ); } if (foutbuf[2] && size > 1) { errs++; fprintf( stderr, "float AND(>) test failed\n" ); } } } MTestPrintfMsg( 10, "Reduce of MPI_DOUBLE\n" ); /* double */ dinbuf[0] = 1; dinbuf[1] = 0; dinbuf[2] = (rank > 0); doutbuf[0] = 0; doutbuf[1] = 1; doutbuf[2] = 1; rc = MPI_Reduce( dinbuf, doutbuf, 3, MPI_DOUBLE, MPI_LAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LAND and MPI_DOUBLE", rc ); errs++; } else { if (rank == 0) { if (!doutbuf[0]) { errs++; fprintf( stderr, "double AND(1) test failed\n" ); } if (doutbuf[1]) { errs++; fprintf( stderr, "double AND(0) test failed\n" ); } if (doutbuf[2] && size > 1) { errs++; fprintf( stderr, "double AND(>) test failed\n" ); } } } #ifdef HAVE_LONG_DOUBLE { long double ldinbuf[3], ldoutbuf[3]; /* long double */ ldinbuf[0] = 1; ldinbuf[1] = 0; ldinbuf[2] = (rank > 0); ldoutbuf[0] = 0; ldoutbuf[1] = 1; ldoutbuf[2] = 1; if (MPI_LONG_DOUBLE != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_DOUBLE\n" ); rc = MPI_Reduce( ldinbuf, ldoutbuf, 3, MPI_LONG_DOUBLE, MPI_LAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LAND and MPI_LONG_DOUBLE", rc ); errs++; } else { if (rank == 0) { if (!ldoutbuf[0]) { errs++; fprintf( stderr, "long double AND(1) test failed\n" ); } if (ldoutbuf[1]) { errs++; fprintf( stderr, "long double AND(0) test failed\n" ); } if (ldoutbuf[2] && size > 1) { errs++; fprintf( stderr, "long double AND(>) test failed\n" ); } } } } } #endif /* HAVE_LONG_DOUBLE */ #endif /* USE_STRICT_MPI */ #ifdef HAVE_LONG_LONG { long long llinbuf[3], lloutbuf[3]; /* long long */ llinbuf[0] = 1; llinbuf[1] = 0; llinbuf[2] = (rank > 0); lloutbuf[0] = 0; lloutbuf[1] = 1; lloutbuf[2] = 1; if (MPI_LONG_LONG != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_LONG\n" ); rc = MPI_Reduce( llinbuf, lloutbuf, 3, MPI_LONG_LONG, MPI_LAND, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LAND and MPI_LONG_LONG", rc ); errs++; } else { if (rank == 0) { if (!lloutbuf[0]) { errs++; fprintf( stderr, "long long AND(1) test failed\n" ); } if (lloutbuf[1]) { errs++; fprintf( stderr, "long long AND(0) test failed\n" ); } if (lloutbuf[2] && size > 1) { errs++; fprintf( stderr, "long long AND(>) test failed\n" ); } } } } } #endif MPI_Errhandler_set( comm, MPI_ERRORS_ARE_FATAL ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/allgather2.c000644 001750 001750 00000002770 12342443661 022306 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitest.h" #include #include /* Gather data from a vector to contiguous. Use IN_PLACE */ int main( int argc, char **argv ) { double *vecout; MPI_Comm comm; int count, minsize = 2; int i, errs = 0; int rank, size; MTest_Init( &argc, &argv ); while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); for (count = 1; count < 9000; count = count * 2) { vecout = (double *)malloc( size * count * sizeof(double) ); for (i=0; i #include #include "mpitest.h" int main( int argc, char **argv ) { int err = 0; int size, rsize, rank, i; int recvcount, /* Each process receives this much data */ sendcount, /* Each process contributes this much data */ basecount; /* Unit of elements - basecount *rsize is recvcount, etc. */ int isLeftGroup; long long *sendbuf, *recvbuf; long long sumval; MPI_Comm comm; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; basecount = 1024; while (MTestGetIntercomm( &comm, &isLeftGroup, 2 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_remote_size( comm, &rsize ); MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); if (0) { printf( "[%d] %s (%d,%d) remote %d\n", rank, isLeftGroup ? "L" : "R", rank, size, rsize ); } recvcount = basecount * rsize; sendcount = basecount * rsize * size; sendbuf = (long long *) malloc( sendcount * sizeof(long long) ); if (!sendbuf) { fprintf( stderr, "Could not allocate %d ints for sendbuf\n", sendcount ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } for (i=0; i #include /* USE_STRICT_MPI may be defined in mpitestconf.h */ #include "mpitestconf.h" #define COUNT (10) #define PRIME (17) #define my_assert(cond_) \ do { \ if (!(cond_)) { \ fprintf(stderr, "assertion (%s) failed, aborting\n", #cond_); \ MPI_Abort(MPI_COMM_WORLD, 1); \ exit(1); \ } \ } while (0) /* Since MPICH is currently the only NBC implementation in existence, just use * this quick-and-dirty #ifdef to decide whether to test the nonblocking * collectives. Eventually we can add a configure option or configure test, or * the MPI-3 standard will be released and these can be gated on a MPI_VERSION * check */ #if !defined(USE_STRICT_MPI) && defined(MPICH) #define TEST_NBC_ROUTINES 1 #endif static void sum_fn(void *invec, void *inoutvec, int *len, MPI_Datatype *datatype) { int i; int *in = invec; int *inout = inoutvec; for (i = 0; i < *len; ++i) { inout[i] = in[i] + inout[i]; } } int main(int argc, char **argv) { int rank, size; int *buf = NULL; int *recvbuf = NULL; int *sendcounts = NULL; int *recvcounts = NULL; int *sdispls = NULL; int *rdispls = NULL; int *sendtypes = NULL; int *recvtypes = NULL; #if defined(TEST_NBC_ROUTINES) int i, j; char *buf_alias = NULL; MPI_Request req; #endif MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); #if defined(TEST_NBC_ROUTINES) buf = malloc(COUNT*size*sizeof(int)); recvbuf = malloc(COUNT*size*sizeof(int)); sendcounts = malloc(size*sizeof(int)); recvcounts = malloc(size*sizeof(int)); sdispls = malloc(size*sizeof(int)); rdispls = malloc(size*sizeof(int)); sendtypes = malloc(size*sizeof(MPI_Datatype)); recvtypes = malloc(size*sizeof(MPI_Datatype)); /* MPI_Ibcast */ for (i = 0; i < COUNT; ++i) { if (rank == 0) { buf[i] = i; } else { buf[i] = 0xdeadbeef; } } MPI_Ibcast(buf, COUNT, MPI_INT, 0, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (i = 0; i < COUNT; ++i) { if (buf[i] != i) printf("buf[%d]=%d i=%d\n", i, buf[i], i); my_assert(buf[i] == i); } /* MPI_Ibcast (again, but designed to stress scatter/allgather impls) */ buf_alias = (char *)buf; my_assert(COUNT*size*sizeof(int) > PRIME); /* sanity */ for (i = 0; i < PRIME; ++i) { if (rank == 0) buf_alias[i] = i; else buf_alias[i] = 0xdb; } for (i = PRIME; i < COUNT * size * sizeof(int); ++i) { buf_alias[i] = 0xbf; } MPI_Ibcast(buf, PRIME, MPI_SIGNED_CHAR, 0, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (i = 0; i < PRIME; ++i) { if (buf_alias[i] != i) printf("buf_alias[%d]=%d i=%d\n", i, buf_alias[i], i); my_assert(buf_alias[i] == i); } /* MPI_Ibarrier */ MPI_Ibarrier(MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); /* MPI_Ireduce */ for (i = 0; i < COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Ireduce(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); if (rank == 0) { for (i = 0; i < COUNT; ++i) { if (recvbuf[i] != ((size * (size-1) / 2) + (i * size))) printf("got recvbuf[%d]=%d, expected %d\n", i, recvbuf[i], ((size * (size-1) / 2) + (i * size))); my_assert(recvbuf[i] == ((size * (size-1) / 2) + (i * size))); } } /* same again, use a user op and free it before the wait */ { MPI_Op op = MPI_OP_NULL; MPI_Op_create(sum_fn, /*commute=*/1, &op); for (i = 0; i < COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Ireduce(buf, recvbuf, COUNT, MPI_INT, op, 0, MPI_COMM_WORLD, &req); MPI_Op_free(&op); MPI_Wait(&req, MPI_STATUS_IGNORE); if (rank == 0) { for (i = 0; i < COUNT; ++i) { if (recvbuf[i] != ((size * (size-1) / 2) + (i * size))) printf("got recvbuf[%d]=%d, expected %d\n", i, recvbuf[i], ((size * (size-1) / 2) + (i * size))); my_assert(recvbuf[i] == ((size * (size-1) / 2) + (i * size))); } } } /* MPI_Iallreduce */ for (i = 0; i < COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Iallreduce(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (i = 0; i < COUNT; ++i) { if (recvbuf[i] != ((size * (size-1) / 2) + (i * size))) printf("got recvbuf[%d]=%d, expected %d\n", i, recvbuf[i], ((size * (size-1) / 2) + (i * size))); my_assert(recvbuf[i] == ((size * (size-1) / 2) + (i * size))); } /* MPI_Ialltoallv (a weak test, neither irregular nor sparse) */ for (i = 0; i < size; ++i) { sendcounts[i] = COUNT; recvcounts[i] = COUNT; sdispls[i] = COUNT * i; rdispls[i] = COUNT * i; for (j = 0; j < COUNT; ++j) { buf[i*COUNT+j] = rank + (i * j); recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Ialltoallv(buf, sendcounts, sdispls, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { /*printf("recvbuf[%d*COUNT+%d]=%d, expecting %d\n", i, j, recvbuf[i*COUNT+j], (i + (rank * j)));*/ my_assert(recvbuf[i*COUNT+j] == (i + (rank * j))); } } /* MPI_Igather */ for (i = 0; i < size*COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Igather(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, 0, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); if (rank == 0) { for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[i*COUNT+j] == i + j); } } } else { for (i = 0; i < size*COUNT; ++i) { my_assert(recvbuf[i] == 0xdeadbeef); } } /* same test again, just use a dup'ed datatype and free it before the wait */ { MPI_Datatype type = MPI_DATATYPE_NULL; MPI_Type_dup(MPI_INT, &type); for (i = 0; i < size*COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Igather(buf, COUNT, MPI_INT, recvbuf, COUNT, type, 0, MPI_COMM_WORLD, &req); MPI_Type_free(&type); /* should cause implementations that don't refcount correctly to blow up or hang in the wait */ MPI_Wait(&req, MPI_STATUS_IGNORE); if (rank == 0) { for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[i*COUNT+j] == i + j); } } } else { for (i = 0; i < size*COUNT; ++i) { my_assert(recvbuf[i] == 0xdeadbeef); } } } /* MPI_Iscatter */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { if (rank == 0) buf[i*COUNT+j] = i + j; else buf[i*COUNT+j] = 0xdeadbeef; recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Iscatter(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, 0, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[j] == rank + j); } if (rank != 0) { for (i = 0; i < size*COUNT; ++i) { /* check we didn't corrupt the sendbuf somehow */ my_assert(buf[i] == 0xdeadbeef); } } /* MPI_Iscatterv */ for (i = 0; i < size; ++i) { /* weak test, just test the regular case where all counts are equal */ sendcounts[i] = COUNT; sdispls[i] = i * COUNT; for (j = 0; j < COUNT; ++j) { if (rank == 0) buf[i*COUNT+j] = i + j; else buf[i*COUNT+j] = 0xdeadbeef; recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Iscatterv(buf, sendcounts, sdispls, MPI_INT, recvbuf, COUNT, MPI_INT, 0, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[j] == rank + j); } if (rank != 0) { for (i = 0; i < size*COUNT; ++i) { /* check we didn't corrupt the sendbuf somehow */ my_assert(buf[i] == 0xdeadbeef); } } for (i = 1; i < size; ++i) { for (j = 0; j < COUNT; ++j) { /* check we didn't corrupt the rest of the recvbuf */ my_assert(recvbuf[i*COUNT+j] == 0xdeadbeef); } } /* MPI_Ireduce_scatter */ for (i = 0; i < size; ++i) { recvcounts[i] = COUNT; for (j = 0; j < COUNT; ++j) { buf[i*COUNT+j] = rank + i; recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Ireduce_scatter(buf, recvbuf, recvcounts, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[j] == (size * rank + ((size - 1) * size) / 2)); } for (i = 1; i < size; ++i) { for (j = 0; j < COUNT; ++j) { /* check we didn't corrupt the rest of the recvbuf */ my_assert(recvbuf[i*COUNT+j] == 0xdeadbeef); } } /* MPI_Ireduce_scatter_block */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { buf[i*COUNT+j] = rank + i; recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Ireduce_scatter_block(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[j] == (size * rank + ((size - 1) * size) / 2)); } for (i = 1; i < size; ++i) { for (j = 0; j < COUNT; ++j) { /* check we didn't corrupt the rest of the recvbuf */ my_assert(recvbuf[i*COUNT+j] == 0xdeadbeef); } } /* MPI_Igatherv */ for (i = 0; i < size*COUNT; ++i) { buf[i] = 0xdeadbeef; recvbuf[i] = 0xdeadbeef; } for (i = 0; i < COUNT; ++i) { buf[i] = rank + i; } for (i = 0; i < size; ++i) { recvcounts[i] = COUNT; rdispls[i] = i * COUNT; } MPI_Igatherv(buf, COUNT, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT, 0, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); if (rank == 0) { for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[i*COUNT+j] == i + j); } } } else { for (i = 0; i < size*COUNT; ++i) { my_assert(recvbuf[i] == 0xdeadbeef); } } /* MPI_Ialltoall */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { buf[i*COUNT+j] = rank + (i * j); recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Ialltoall(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { /*printf("recvbuf[%d*COUNT+%d]=%d, expecting %d\n", i, j, recvbuf[i*COUNT+j], (i + (i * j)));*/ my_assert(recvbuf[i*COUNT+j] == (i + (rank * j))); } } /* MPI_Iallgather */ for (i = 0; i < size*COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Iallgather(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[i*COUNT+j] == i + j); } } /* MPI_Iallgatherv */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { recvbuf[i*COUNT+j] = 0xdeadbeef; } recvcounts[i] = COUNT; rdispls[i] = i * COUNT; } for (i = 0; i < COUNT; ++i) buf[i] = rank + i; MPI_Iallgatherv(buf, COUNT, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[i*COUNT+j] == i + j); } } /* MPI_Iscan */ for (i = 0; i < COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Iscan(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (i = 0; i < COUNT; ++i) { my_assert(recvbuf[i] == ((rank * (rank+1) / 2) + (i * (rank + 1)))); } /* MPI_Iexscan */ for (i = 0; i < COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Iexscan(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (i = 0; i < COUNT; ++i) { if (rank == 0) my_assert(recvbuf[i] == 0xdeadbeef); else my_assert(recvbuf[i] == ((rank * (rank+1) / 2) + (i * (rank + 1)) - (rank + i))); } /* MPI_Ialltoallw (a weak test, neither irregular nor sparse) */ for (i = 0; i < size; ++i) { sendcounts[i] = COUNT; recvcounts[i] = COUNT; sdispls[i] = COUNT * i * sizeof(int); rdispls[i] = COUNT * i * sizeof(int); sendtypes[i] = MPI_INT; recvtypes[i] = MPI_INT; for (j = 0; j < COUNT; ++j) { buf[i*COUNT+j] = rank + (i * j); recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Ialltoallw(buf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, MPI_COMM_WORLD, &req); MPI_Wait(&req, MPI_STATUS_IGNORE); for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { /*printf("recvbuf[%d*COUNT+%d]=%d, expecting %d\n", i, j, recvbuf[i*COUNT+j], (i + (rank * j)));*/ my_assert(recvbuf[i*COUNT+j] == (i + (rank * j))); } } #endif /* defined(TEST_NBC_ROUTINES) */ if (rank == 0) printf(" No Errors\n"); MPI_Finalize(); free(buf); free(recvbuf); free(sendcounts); free(recvcounts); free(rdispls); free(sdispls); free(recvtypes); free(sendtypes); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/opbor.c000644 001750 001750 00000023235 12342443661 021401 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitestconf.h" #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_BOR operations on optional datatypes dupported by MPICH"; */ /* * This test looks at the handling of logical and for types that are not * integers or are not required integers (e.g., long long). MPICH allows * these as well. A strict MPI test should not include this test. */ int main( int argc, char *argv[] ) { int errs = 0; int rc; int rank, size; MPI_Comm comm; char cinbuf[3], coutbuf[3]; signed char scinbuf[3], scoutbuf[3]; unsigned char ucinbuf[3], ucoutbuf[3]; short sinbuf[3], soutbuf[3]; unsigned short usinbuf[3], usoutbuf[3]; long linbuf[3], loutbuf[3]; unsigned long ulinbuf[3], uloutbuf[3]; unsigned uinbuf[3], uoutbuf[3]; int iinbuf[3], ioutbuf[3]; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; /* Set errors return so that we can provide better information should a routine reject one of the operand/datatype pairs */ MPI_Errhandler_set( comm, MPI_ERRORS_RETURN ); MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); #ifndef USE_STRICT_MPI /* char */ MTestPrintfMsg( 10, "Reduce of MPI_CHAR\n" ); cinbuf[0] = 0xff; cinbuf[1] = 0; cinbuf[2] = (rank > 0) ? 0x3c : 0xc3; coutbuf[0] = 0; coutbuf[1] = 1; coutbuf[2] = 1; rc = MPI_Reduce( cinbuf, coutbuf, 3, MPI_CHAR, MPI_BOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BOR and MPI_CHAR", rc ); errs++; } else { if (rank == 0) { if (coutbuf[0] != (char)0xff) { errs++; fprintf( stderr, "char BOR(1) test failed\n" ); } if (coutbuf[1]) { errs++; fprintf( stderr, "char BOR(0) test failed\n" ); } if (coutbuf[2] != (char)0xff && size > 1) { errs++; fprintf( stderr, "char BOR(>) test failed\n" ); } } } #endif /* USE_STRICT_MPI */ /* signed char */ MTestPrintfMsg( 10, "Reduce of MPI_SIGNED_CHAR\n" ); scinbuf[0] = 0xff; scinbuf[1] = 0; scinbuf[2] = (rank > 0) ? 0x3c : 0xc3; scoutbuf[0] = 0; scoutbuf[1] = 1; scoutbuf[2] = 1; rc = MPI_Reduce( scinbuf, scoutbuf, 3, MPI_SIGNED_CHAR, MPI_BOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BOR and MPI_SIGNED_CHAR", rc ); errs++; } else { if (rank == 0) { if (scoutbuf[0] != (signed char)0xff) { errs++; fprintf( stderr, "signed char BOR(1) test failed\n" ); } if (scoutbuf[1]) { errs++; fprintf( stderr, "signed char BOR(0) test failed\n" ); } if (scoutbuf[2] != (signed char)0xff && size > 1) { errs++; fprintf( stderr, "signed char BOR(>) test failed\n" ); } } } /* unsigned char */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_CHAR\n" ); ucinbuf[0] = 0xff; ucinbuf[1] = 0; ucinbuf[2] = (rank > 0) ? 0x3c : 0xc3; ucoutbuf[0] = 0; ucoutbuf[1] = 1; ucoutbuf[2] = 1; rc = MPI_Reduce( ucinbuf, ucoutbuf, 3, MPI_UNSIGNED_CHAR, MPI_BOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BOR and MPI_UNSIGNED_CHAR", rc ); errs++; } else { if (rank == 0) { if (ucoutbuf[0] != 0xff) { errs++; fprintf( stderr, "unsigned char BOR(1) test failed\n" ); } if (ucoutbuf[1]) { errs++; fprintf( stderr, "unsigned char BOR(0) test failed\n" ); } if (ucoutbuf[2] != 0xff && size > 1) { errs++; fprintf( stderr, "unsigned char BOR(>) test failed\n" ); } } } /* bytes */ MTestPrintfMsg( 10, "Reduce of MPI_BYTE\n" ); cinbuf[0] = 0xff; cinbuf[1] = 0; cinbuf[2] = (rank > 0) ? 0x3c : 0xc3; coutbuf[0] = 0; coutbuf[1] = 1; coutbuf[2] = 1; rc = MPI_Reduce( cinbuf, coutbuf, 3, MPI_BYTE, MPI_BOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BOR and MPI_BYTE", rc ); errs++; } else { if (rank == 0) { if (coutbuf[0] != (char)0xff) { errs++; fprintf( stderr, "byte BOR(1) test failed\n" ); } if (coutbuf[1]) { errs++; fprintf( stderr, "byte BOR(0) test failed\n" ); } if (coutbuf[2] != (char)0xff && size > 1) { errs++; fprintf( stderr, "byte BOR(>) test failed\n" ); } } } /* short */ MTestPrintfMsg( 10, "Reduce of MPI_SHORT\n" ); sinbuf[0] = 0xffff; sinbuf[1] = 0; sinbuf[2] = (rank > 0) ? 0x3c3c : 0xc3c3; soutbuf[0] = 0; soutbuf[1] = 1; soutbuf[2] = 1; rc = MPI_Reduce( sinbuf, soutbuf, 3, MPI_SHORT, MPI_BOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BOR and MPI_SHORT", rc ); errs++; } else { if (rank == 0) { if (soutbuf[0] != (short)0xffff) { errs++; fprintf( stderr, "short BOR(1) test failed\n" ); } if (soutbuf[1]) { errs++; fprintf( stderr, "short BOR(0) test failed\n" ); } if (soutbuf[2] != (short)0xffff && size > 1) { errs++; fprintf( stderr, "short BOR(>) test failed\n" ); } } } /* unsigned short */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_SHORT\n" ); usinbuf[0] = 0xffff; usinbuf[1] = 0; usinbuf[2] = (rank > 0) ? 0x3c3c : 0xc3c3; usoutbuf[0] = 0; usoutbuf[1] = 1; usoutbuf[2] = 1; rc = MPI_Reduce( usinbuf, usoutbuf, 3, MPI_UNSIGNED_SHORT, MPI_BOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BOR and MPI_UNSIGNED_SHORT", rc ); errs++; } else { if (rank == 0) { if (usoutbuf[0] != 0xffff) { errs++; fprintf( stderr, "short BOR(1) test failed\n" ); } if (usoutbuf[1]) { errs++; fprintf( stderr, "short BOR(0) test failed\n" ); } if (usoutbuf[2] != 0xffff && size > 1) { errs++; fprintf( stderr, "short BOR(>) test failed\n" ); } } } /* unsigned */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED\n" ); uinbuf[0] = 0xffffffff; uinbuf[1] = 0; uinbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3; uoutbuf[0] = 0; uoutbuf[1] = 1; uoutbuf[2] = 1; rc = MPI_Reduce( uinbuf, uoutbuf, 3, MPI_UNSIGNED, MPI_BOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BOR and MPI_UNSIGNED", rc ); errs++; } else { if (rank == 0) { if (uoutbuf[0] != 0xffffffff) { errs++; fprintf( stderr, "unsigned BOR(1) test failed\n" ); } if (uoutbuf[1]) { errs++; fprintf( stderr, "unsigned BOR(0) test failed\n" ); } if (uoutbuf[2] != 0xffffffff && size > 1) { errs++; fprintf( stderr, "unsigned BOR(>) test failed\n" ); } } } /* int */ MTestPrintfMsg( 10, "Reduce of MPI_INT\n" ); iinbuf[0] = 0xffffffff; iinbuf[1] = 0; iinbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3; ioutbuf[0] = 0; ioutbuf[1] = 1; ioutbuf[2] = 1; rc = MPI_Reduce( iinbuf, ioutbuf, 3, MPI_INT, MPI_BOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BOR and MPI_INT", rc ); errs++; } else { if (rank == 0) { if (ioutbuf[0] != 0xffffffff) { errs++; fprintf( stderr, "int BOR(1) test failed\n" ); } if (ioutbuf[1]) { errs++; fprintf( stderr, "int BOR(0) test failed\n" ); } if (ioutbuf[2] != 0xffffffff && size > 1) { errs++; fprintf( stderr, "int BOR(>) test failed\n" ); } } } /* long */ MTestPrintfMsg( 10, "Reduce of MPI_LONG\n" ); linbuf[0] = 0xffffffff; linbuf[1] = 0; linbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3; loutbuf[0] = 0; loutbuf[1] = 1; loutbuf[2] = 1; rc = MPI_Reduce( linbuf, loutbuf, 3, MPI_LONG, MPI_BOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BOR and MPI_LONG", rc ); errs++; } else { if (rank == 0) { if (loutbuf[0] != 0xffffffff) { errs++; fprintf( stderr, "long BOR(1) test failed\n" ); } if (loutbuf[1]) { errs++; fprintf( stderr, "long BOR(0) test failed\n" ); } if (loutbuf[2] != 0xffffffff && size > 1) { errs++; fprintf( stderr, "long BOR(>) test failed\n" ); } } } /* unsigned long */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_LONG\n" ); ulinbuf[0] = 0xffffffff; ulinbuf[1] = 0; ulinbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3; uloutbuf[0] = 0; uloutbuf[1] = 1; uloutbuf[2] = 1; rc = MPI_Reduce( ulinbuf, uloutbuf, 3, MPI_UNSIGNED_LONG, MPI_BOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BOR and MPI_UNSIGNED_LONG", rc ); errs++; } else { if (rank == 0) { if (uloutbuf[0] != 0xffffffff) { errs++; fprintf( stderr, "unsigned long BOR(1) test failed\n" ); } if (uloutbuf[1]) { errs++; fprintf( stderr, "unsigned long BOR(0) test failed\n" ); } if (uloutbuf[2] != 0xffffffff && size > 1) { errs++; fprintf( stderr, "unsigned long BOR(>) test failed\n" ); } } } #ifdef HAVE_LONG_LONG { long long llinbuf[3], lloutbuf[3]; /* long long */ llinbuf[0] = 0xffffffff; llinbuf[1] = 0; llinbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3; lloutbuf[0] = 0; lloutbuf[1] = 1; lloutbuf[2] = 1; if (MPI_LONG_LONG != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_LONG\n" ); rc = MPI_Reduce( llinbuf, lloutbuf, 3, MPI_LONG_LONG, MPI_BOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BOR and MPI_LONG_LONG", rc ); errs++; } else { if (rank == 0) { if (lloutbuf[0] != 0xffffffff) { errs++; fprintf( stderr, "long long BOR(1) test failed\n" ); } if (lloutbuf[1]) { errs++; fprintf( stderr, "long long BOR(0) test failed\n" ); } if (lloutbuf[2] != 0xffffffff && size > 1) { errs++; fprintf( stderr, "long long BOR(>) test failed\n" ); } } } } } #endif MPI_Errhandler_set( comm, MPI_ERRORS_ARE_FATAL ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/coll3.c000644 001750 001750 00000005250 12342443661 021271 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" #define MAX_PROCESSES 10 int main( int argc, char **argv ) { int rank, size, i,j; int table[MAX_PROCESSES][MAX_PROCESSES]; int errors=0; int participants; int displs[MAX_PROCESSES]; int recv_counts[MAX_PROCESSES]; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); /* A maximum of MAX_PROCESSES processes can participate */ if ( size > MAX_PROCESSES ) participants = MAX_PROCESSES; else participants = size; /* while (MAX_PROCESSES % participants) participants--; */ if (MAX_PROCESSES % participants) { fprintf( stderr, "Number of processors must divide %d\n", MAX_PROCESSES ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } if ( (rank < participants) ) { /* Determine what rows are my responsibility */ int block_size = MAX_PROCESSES / participants; int begin_row = rank * block_size; int end_row = (rank+1) * block_size; int send_count = block_size * MAX_PROCESSES; /* Fill in the displacements and recv_counts */ for (i=0; i #include "mpitest.h" /* static char MTEST_Descrip[] = "Test of broadcast with various roots and datatypes"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int rank, size, root; int minsize = 2, count; MPI_Comm comm; MTestDatatype sendtype, recvtype; MTest_Init( &argc, &argv ); /* The following illustrates the use of the routines to run through a selection of communicators and datatypes. Use subsets of these for tests that do not involve combinations of communicators, datatypes, and counts of datatypes */ while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Errhandler_set( comm, MPI_ERRORS_RETURN ); /* The max value of count must be very large to ensure that we reach the long message algorithms */ for (count = 1; count < 280000; count = count * 4) { while (MTestGetDatatypes( &sendtype, &recvtype, count )) { for (root=0; root #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_LXOR operations on optional datatypes dupported by MPICH"; */ /* * This test looks at the handling of logical and for types that are not * integers or are not required integers (e.g., long long). MPICH allows * these as well. A strict MPI test should not include this test. */ int main( int argc, char *argv[] ) { int errs = 0; int rc; int rank, size; MPI_Comm comm; char cinbuf[3], coutbuf[3]; signed char scinbuf[3], scoutbuf[3]; unsigned char ucinbuf[3], ucoutbuf[3]; float finbuf[3], foutbuf[3]; double dinbuf[3], doutbuf[3]; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; /* Set errors return so that we can provide better information should a routine reject one of the operand/datatype pairs */ MPI_Errhandler_set( comm, MPI_ERRORS_RETURN ); MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); #ifndef USE_STRICT_MPI /* char */ MTestPrintfMsg( 10, "Reduce of MPI_CHAR\n" ); cinbuf[0] = 1; cinbuf[1] = 0; cinbuf[2] = (rank > 0); coutbuf[0] = 0; coutbuf[1] = 1; coutbuf[2] = 1; rc = MPI_Reduce( cinbuf, coutbuf, 3, MPI_CHAR, MPI_LXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LXOR and MPI_CHAR", rc ); errs++; } else { if (rank == 0) { if (coutbuf[0] != (size % 2)) { errs++; fprintf( stderr, "char XOR(1) test failed\n" ); } if (coutbuf[1]) { errs++; fprintf( stderr, "char XOR(0) test failed\n" ); } if (coutbuf[2] == (size % 2) && size > 1) { errs++; fprintf( stderr, "char XOR(>) test failed\n" ); } } } #endif /* USE_STRICT_MPI */ /* signed char */ MTestPrintfMsg( 10, "Reduce of MPI_SIGNED_CHAR\n" ); scinbuf[0] = 1; scinbuf[1] = 0; scinbuf[2] = (rank > 0); scoutbuf[0] = 0; scoutbuf[1] = 1; scoutbuf[2] = 1; rc = MPI_Reduce( scinbuf, scoutbuf, 3, MPI_SIGNED_CHAR, MPI_LXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LXOR and MPI_SIGNED_CHAR", rc ); errs++; } else { if (rank == 0) { if (scoutbuf[0] != (size % 2)) { errs++; fprintf( stderr, "signed char XOR(1) test failed\n" ); } if (scoutbuf[1]) { errs++; fprintf( stderr, "signed char XOR(0) test failed\n" ); } if (scoutbuf[2] == (size % 2) && size > 1) { errs++; fprintf( stderr, "signed char XOR(>) test failed\n" ); } } } /* unsigned char */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_CHAR\n" ); ucinbuf[0] = 1; ucinbuf[1] = 0; ucinbuf[2] = (rank > 0); ucoutbuf[0] = 0; ucoutbuf[1] = 1; ucoutbuf[2] = 1; rc = MPI_Reduce( ucinbuf, ucoutbuf, 3, MPI_UNSIGNED_CHAR, MPI_LXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LXOR and MPI_UNSIGNED_CHAR", rc ); errs++; } else { if (rank == 0) { if (ucoutbuf[0] != (size % 2)) { errs++; fprintf( stderr, "unsigned char XOR(1) test failed\n" ); } if (ucoutbuf[1]) { errs++; fprintf( stderr, "unsigned char XOR(0) test failed\n" ); } if (ucoutbuf[2] == (size % 2) && size > 1) { errs++; fprintf( stderr, "unsigned char XOR(>) test failed\n" ); } } } #ifndef USE_STRICT_MPI /* float */ MTestPrintfMsg( 10, "Reduce of MPI_FLOAT\n" ); finbuf[0] = 1; finbuf[1] = 0; finbuf[2] = (rank > 0); foutbuf[0] = 0; foutbuf[1] = 1; foutbuf[2] = 1; rc = MPI_Reduce( finbuf, foutbuf, 3, MPI_FLOAT, MPI_LXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LXOR and MPI_FLOAT", rc ); errs++; } else { if (rank == 0) { if (foutbuf[0] != (size % 2)) { errs++; fprintf( stderr, "float XOR(1) test failed\n" ); } if (foutbuf[1]) { errs++; fprintf( stderr, "float XOR(0) test failed\n" ); } if (foutbuf[2] == (size % 2) && size > 1) { errs++; fprintf( stderr, "float XOR(>) test failed\n" ); } } } /* double */ MTestPrintfMsg( 10, "Reduce of MPI_DOUBLE\n" ); dinbuf[0] = 1; dinbuf[1] = 0; dinbuf[2] = (rank > 0); doutbuf[0] = 0; doutbuf[1] = 1; doutbuf[2] = 1; rc = MPI_Reduce( dinbuf, doutbuf, 3, MPI_DOUBLE, MPI_LXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LXOR and MPI_DOUBLE", rc ); errs++; } else { if (rank == 0) { if (doutbuf[0] != (size % 2)) { errs++; fprintf( stderr, "double XOR(1) test failed\n" ); } if (doutbuf[1]) { errs++; fprintf( stderr, "double XOR(0) test failed\n" ); } if (doutbuf[2] == (size % 2) && size > 1) { errs++; fprintf( stderr, "double XOR(>) test failed\n" ); } } } #ifdef HAVE_LONG_DOUBLE { long double ldinbuf[3], ldoutbuf[3]; /* long double */ ldinbuf[0] = 1; ldinbuf[1] = 0; ldinbuf[2] = (rank > 0); ldoutbuf[0] = 0; ldoutbuf[1] = 1; ldoutbuf[2] = 1; if (MPI_LONG_DOUBLE != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_DOUBLE\n" ); rc = MPI_Reduce( ldinbuf, ldoutbuf, 3, MPI_LONG_DOUBLE, MPI_LXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LXOR and MPI_LONG_DOUBLE", rc ); errs++; } else { if (rank == 0) { if (ldoutbuf[0] != (size % 2)) { errs++; fprintf( stderr, "long double XOR(1) test failed\n" ); } if (ldoutbuf[1]) { errs++; fprintf( stderr, "long double XOR(0) test failed\n" ); } if (ldoutbuf[2] == (size % 2) && size > 1) { errs++; fprintf( stderr, "long double XOR(>) test failed\n" ); } } } } } #endif /* HAVE_LONG_DOUBLE */ #endif /* USE_STRICT_MPI */ #ifdef HAVE_LONG_LONG { long long llinbuf[3], lloutbuf[3]; /* long long */ llinbuf[0] = 1; llinbuf[1] = 0; llinbuf[2] = (rank > 0); lloutbuf[0] = 0; lloutbuf[1] = 1; lloutbuf[2] = 1; if (MPI_LONG_LONG != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_LONG\n" ); rc = MPI_Reduce( llinbuf, lloutbuf, 3, MPI_LONG_LONG, MPI_LXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_LXOR and MPI_LONG_LONG", rc ); errs++; } else { if (rank == 0) { if (lloutbuf[0] != (size % 2)) { errs++; fprintf( stderr, "long long XOR(1) test failed\n" ); } if (lloutbuf[1]) { errs++; fprintf( stderr, "long long XOR(0) test failed\n" ); } if (lloutbuf[2] == (size % 2) && size > 1) { errs++; fprintf( stderr, "long long XOR(>) test failed\n" ); } } } } } #endif MPI_Errhandler_set( comm, MPI_ERRORS_ARE_FATAL ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/allred3.c000644 001750 001750 00000012303 12342443661 021600 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" #include /* static char MTEST_Descrip[] = "Test MPI_Allreduce with non-commutative user-defined operations"; */ /* We make the error count global so that we can easily control the output of error information (in particular, limiting it after the first 10 errors */ int errs = 0; /* This implements a simple matrix-matrix multiply. This is an associative but not commutative operation. The matrix size is set in matSize; the number of matrices is the count argument. The matrix is stored in C order, so that c(i,j) is cin[j+i*matSize] */ #define MAXCOL 256 static int matSize = 0; /* Must be < MAXCOL */ static int max_offset = 0; void uop( void *, void *, int *, MPI_Datatype * ); void uop( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype ) { const int *cin = (const int *)cinPtr; int *cout = (int *)coutPtr; int i, j, k, nmat; int tempcol[MAXCOL]; int offset1, offset2; int matsize2 = matSize*matSize; for (nmat = 0; nmat < *count; nmat++) { for (j=0; j #include "mpitest.h" void addem ( int *, int *, int *, MPI_Datatype * ); void assoc ( int *, int *, int *, MPI_Datatype * ); void addem(int *invec, int *inoutvec, int *len, MPI_Datatype *dtype) { int i; for ( i=0; i<*len; i++ ) inoutvec[i] += invec[i]; } #define BAD_ANSWER 100000 /* The operation is inoutvec[i] = invec[i] op inoutvec[i] (see 4.9.4). The order is important. Note that the computation is in process rank (in the communicator) order, independant of the root. */ void assoc(int *invec, int *inoutvec, int *len, MPI_Datatype *dtype) { int i; for ( i=0; i<*len; i++ ) { if (inoutvec[i] <= invec[i] ) { int rank; MPI_Comm_rank( MPI_COMM_WORLD, &rank ); fprintf( stderr, "[%d] inout[0] = %d, in[0] = %d\n", rank, inoutvec[0], invec[0] ); inoutvec[i] = BAD_ANSWER; } else inoutvec[i] = invec[i]; } } int main( int argc, char **argv ) { int rank, size, i; int data; int errors=0; int result = -100; int correct_result; MPI_Op op_assoc, op_addem; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); data = rank; correct_result = 0; for (i=0;i<=rank;i++) correct_result += i; MPI_Scan ( &data, &result, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD ); if (result != correct_result) { fprintf( stderr, "[%d] Error suming ints with scan\n", rank ); errors++; } MPI_Scan ( &data, &result, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD ); if (result != correct_result) { fprintf( stderr, "[%d] Error summing ints with scan (2)\n", rank ); errors++; } data = rank; result = -100; MPI_Op_create( (MPI_User_function *)assoc, 0, &op_assoc ); MPI_Op_create( (MPI_User_function *)addem, 1, &op_addem ); MPI_Scan ( &data, &result, 1, MPI_INT, op_addem, MPI_COMM_WORLD ); if (result != correct_result) { fprintf( stderr, "[%d] Error summing ints with scan (userop)\n", rank ); errors++; } MPI_Scan ( &data, &result, 1, MPI_INT, op_addem, MPI_COMM_WORLD ); if (result != correct_result) { fprintf( stderr, "[%d] Error summing ints with scan (userop2)\n", rank ); errors++; } result = -100; data = rank; MPI_Scan ( &data, &result, 1, MPI_INT, op_assoc, MPI_COMM_WORLD ); if (result == BAD_ANSWER) { fprintf( stderr, "[%d] Error scanning with non-commutative op\n", rank ); errors++; } MPI_Op_free( &op_assoc ); MPI_Op_free( &op_addem ); MTest_Finalize( errors ); MPI_Finalize(); return MTestReturnValue( errors ); } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/icallreduce.c000644 001750 001750 00000004103 12342443661 022525 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple intercomm allreduce test"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int *sendbuf = 0, *recvbuf = 0; int leftGroup, i, count, rank, rsize; MPI_Comm comm; MPI_Datatype datatype; MTest_Init( &argc, &argv ); datatype = MPI_INT; /* Get an intercommunicator */ while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_rank( comm, &rank ); MPI_Comm_remote_size( comm, &rsize ); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Errhandler_set( comm, MPI_ERRORS_RETURN ); for (count = 1; count < 65000; count = 2 * count) { /* printf( "rank = %d(%d)\n", rank, leftGroup ); fflush(stdout); */ sendbuf = (int *)malloc( count * sizeof(int) ); recvbuf = (int *)malloc( count * sizeof(int) ); if (leftGroup) { for (i=0; i #include #include #if !defined(USE_STRICT_MPI) && defined(MPICH) #define TEST_NBC_ROUTINES 1 #endif int main(int argc, char *argv[]) { #if defined(TEST_NBC_ROUTINES) MPI_Request barrier; int i,done; #endif int rank; MPI_Init(&argc,&argv); MPI_Comm_rank(MPI_COMM_WORLD,&rank); #if defined(TEST_NBC_ROUTINES) MPI_Ibarrier(MPI_COMM_WORLD,&barrier); for (i=0,done=0; !done; i++) { usleep(1000); /*printf("[%d] MPI_Test: %d\n",rank,i);*/ MPI_Test(&barrier,&done,MPI_STATUS_IGNORE); } #endif if (rank == 0) printf(" No Errors\n"); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/coll6.c000644 001750 001750 00000005056 12342443661 021300 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" #define MAX_PROCESSES 10 int main( int argc, char **argv ) { int rank, size, i,j; int table[MAX_PROCESSES][MAX_PROCESSES]; int errors=0; int participants; int displs[MAX_PROCESSES]; int recv_counts[MAX_PROCESSES]; MPI_Comm test_comm; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); /* A maximum of MAX_PROCESSES processes can participate */ participants = ( size > MAX_PROCESSES ) ? MAX_PROCESSES : size; if (MAX_PROCESSES % participants) { fprintf( stderr, "Number of processors must divide %d\n", MAX_PROCESSES ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Comm_split(MPI_COMM_WORLD, rank #include /* This example sends a vector and receives individual elements */ int main( int argc, char **argv ) { MPI_Datatype vec; double *vecin, *vecout, ivalue; int root, i, n, stride, err = 0; int rank, size; MPI_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); n = 12; stride = 10; vecin = (double *)malloc( n * stride * size * sizeof(double) ); vecout = (double *)malloc( n * sizeof(double) ); MPI_Type_vector( n, 1, stride, MPI_DOUBLE, &vec ); MPI_Type_commit( &vec ); for (i=0; i 0) printf( "Found %d errors!\n", err ); else printf( " No Errors\n" ); } MPI_Type_free( &vec ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/scatter2.c000644 001750 001750 00000003740 12342443661 022006 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitest.h" #include #include /* This example sends a vector and receives individual elements, but the root process does not receive any data */ int main( int argc, char **argv ) { MPI_Datatype vec; double *vecin, *vecout, ivalue; int root, i, n, stride, err = 0; int rank, size; MPI_Aint vextent; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); n = 12; stride = 10; vecin = (double *)malloc( n * stride * size * sizeof(double) ); vecout = (double *)malloc( n * sizeof(double) ); MPI_Type_vector( n, 1, stride, MPI_DOUBLE, &vec ); MPI_Type_commit( &vec ); MPI_Type_extent( vec, &vextent ); if (vextent != ((n-1)*(MPI_Aint)stride + 1) * sizeof(double) ) { err++; printf( "Vector extent is %ld, should be %ld\n", (long) vextent, (long)(((n-1)*stride+1)*sizeof(double)) ); } /* Note that the exted of type vector is from the first to the last element, not n*stride. E.g., with n=1, the extent is a single double */ for (i=0; i #include "mpi.h" #include "mpitest.h" #define TABLE_SIZE 2 int main( int argc, char **argv ) { int rank, size; double a[TABLE_SIZE]; struct { double a; int b; } in[TABLE_SIZE], out[TABLE_SIZE]; int i; int errors = 0; /* Initialize the environment and some variables */ MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); /* Initialize the maxloc data */ for ( i=0; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple intercomm barrier test"; */ /* This only checks that the Barrier operation accepts intercommunicators. It does not check for the semantics of a intercomm barrier (all processes in the local group can exit when (but not before) all processes in the remote group enter the barrier */ int main( int argc, char *argv[] ) { int errs = 0, err; int leftGroup; MPI_Comm comm; /* MPI_Datatype datatype; */ MTest_Init( &argc, &argv ); /* datatype = MPI_INT; */ /* Get an intercommunicator */ while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN ); if (leftGroup) { err = MPI_Barrier( comm ); if (err) { errs++; MTestPrintError( err ); } } else { /* In the right group */ err = MPI_Barrier( comm ); if (err) { errs++; MTestPrintError( err ); } } MTestFreeComm( &comm ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/icallgatherv.c000644 001750 001750 00000005711 12342443661 022724 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple intercomm allgatherv test"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int *rbuf = 0, *sbuf = 0; int *recvcounts, *recvdispls; int leftGroup, i, count, rank, rsize; MPI_Comm comm; MPI_Datatype datatype; MTest_Init( &argc, &argv ); datatype = MPI_INT; /* Get an intercommunicator */ while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_rank( comm, &rank ); MPI_Comm_remote_size( comm, &rsize ); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Errhandler_set( comm, MPI_ERRORS_RETURN ); for (count = 1; count < 65000; count = 2 * count) { /* The left group will send rank to the right group; The right group will send -rank to the left group */ rbuf = (int *)malloc( count * rsize * sizeof(int) ); sbuf = (int *)malloc( count * sizeof(int) ); recvcounts = (int *) malloc( rsize * sizeof(int) ); recvdispls = (int *) malloc( rsize * sizeof(int) ); for (i=0; i #include #include /* This program tests MPI_Alltoallv by having processor i send different amounts of data to each processor. Because there are separate send and receive types to alltoallv, there need to be tests to rearrange data on the fly. Not done yet. The first test sends i items to processor i from all processors. Currently, the test uses only MPI_INT; this is adequate for testing systems that use point-to-point operations */ int main( int argc, char **argv ) { MPI_Comm comm; int *sbuf, *rbuf; int rank, size; int *sendcounts, *recvcounts, *rdispls, *sdispls; int i, j, *p, err; MTest_Init( &argc, &argv ); err = 0; while (MTestGetIntracommGeneral( &comm, 2, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Create the buffer */ MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); sbuf = (int *)malloc( size * size * sizeof(int) ); rbuf = (int *)malloc( size * size * sizeof(int) ); if (!sbuf || !rbuf) { fprintf( stderr, "Could not allocated buffers!\n" ); MPI_Abort( comm, 1 ); exit(1); } /* Load up the buffers */ for (i=0; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "A simple test of MPI_Op_create/commute/free"; */ static int errs = 0; /* static void comm_user_op(void *invec, void *inoutvec, int *len, MPI_Datatype *datatype) { user_op(invec, inoutvec, len, datatype); } */ /* static void noncomm_user_op(void *invec, void *inoutvec, int *len, MPI_Datatype *datatype) { user_op(invec, inoutvec, len, datatype); } */ static void user_op(void *invec, void *inoutvec, int *len, MPI_Datatype *datatype) { int i; int *invec_int = (int *)invec; int *inoutvec_int = (int *)inoutvec; if (*datatype != MPI_INT) { ++errs; printf("invalid datatype passed to user_op"); return; } for (i = 0; i < *len; ++i) { inoutvec_int[i] = invec_int[i] * 2 + inoutvec_int[i]; } } int main( int argc, char *argv[] ) { MPI_Op c_uop = MPI_OP_NULL; MPI_Op nc_uop = MPI_OP_NULL; #if MTEST_HAVE_MIN_MPI_VERSION(2,2) int is_commutative = 0; #endif MTest_Init(&argc, &argv); /* make sure that user-define ops work too */ MPI_Op_create(&user_op, 1/*commute*/, &c_uop); MPI_Op_create(&user_op, 0/*!commute*/, &nc_uop); #if MTEST_HAVE_MIN_MPI_VERSION(2,2) /* this function was added in MPI-2.2 */ #define CHECK_COMMUTATIVE(op_) \ do { \ MPI_Op_commutative((op_), &is_commutative); \ if (!is_commutative) { ++errs; } \ } while (0) /* Check all predefined reduction operations for commutivity. * This list is from section 5.9.2 of the MPI-2.1 standard */ CHECK_COMMUTATIVE(MPI_MAX); CHECK_COMMUTATIVE(MPI_MIN); CHECK_COMMUTATIVE(MPI_SUM); CHECK_COMMUTATIVE(MPI_PROD); CHECK_COMMUTATIVE(MPI_LAND); CHECK_COMMUTATIVE(MPI_BAND); CHECK_COMMUTATIVE(MPI_LOR); CHECK_COMMUTATIVE(MPI_BOR); CHECK_COMMUTATIVE(MPI_LXOR); CHECK_COMMUTATIVE(MPI_BXOR); CHECK_COMMUTATIVE(MPI_MAXLOC); CHECK_COMMUTATIVE(MPI_MINLOC); #undef CHECK_COMMUTATIVE MPI_Op_commutative(c_uop, &is_commutative); if (!is_commutative) { ++errs; } /* also check our non-commutative user defined operation */ MPI_Op_commutative(nc_uop, &is_commutative); if (is_commutative) { ++errs; } #endif MPI_Op_free(&nc_uop); MPI_Op_free(&c_uop); MTest_Finalize(errs); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/exscan2.c000644 001750 001750 00000002510 12342443661 021614 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_Exscan (simple test)"; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size; int sendbuf[1], recvbuf[1]; MPI_Comm comm; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); sendbuf[0] = rank; recvbuf[0] = -2; MPI_Exscan( sendbuf, recvbuf, 1, MPI_INT, MPI_SUM, comm ); /* Check the results. rank 0 has no data. Input is 0 1 2 3 4 5 6 7 8 ... Output is - 0 1 3 6 10 15 21 28 36 (scan, not counting the contribution from the calling process) */ if (rank > 0) { int result = (((rank) * (rank-1))/2); /* printf( "%d: %d\n", rank, result ); */ if (recvbuf[0] != result) { errs++; fprintf( stderr, "Error in recvbuf = %d on %d, expected %d\n", recvbuf[0], rank, result ); } } else if (recvbuf[0] != -2) { errs++; fprintf( stderr, "Error in recvbuf on zero, is %d\n", recvbuf[0] ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/coll5.c000644 001750 001750 00000003205 12342443661 021271 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" #define MAX_PROCESSES 10 int main( int argc, char **argv ) { int rank, size, i,j; int table[MAX_PROCESSES][MAX_PROCESSES]; int row[MAX_PROCESSES]; int errors=0; int participants; int displs[MAX_PROCESSES]; int send_counts[MAX_PROCESSES]; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); /* A maximum of MAX_PROCESSES processes can participate */ if ( size > MAX_PROCESSES ) participants = MAX_PROCESSES; else participants = size; if ( (rank < participants) ) { int recv_count = MAX_PROCESSES; /* If I'm the root (process 0), then fill out the big table */ /* and setup send_counts and displs arrays */ if (rank == 0) for ( i=0; i #include #include #include /* USE_STRICT_MPI may be defined in mpitestconf.h */ #include "mpitestconf.h" #ifdef HAVE_UNISTD_H #include #endif static int errs = 0; /* Constants that control the high level test harness behavior. */ /* MAIN_ITERATIONS is how many NBC ops the test will attempt to issue. */ #define MAIN_ITERATIONS (100000) /* WINDOW is the maximum number of outstanding NBC requests at any given time */ #define WINDOW (20) /* we sleep with probability 1/CHANCE_OF_SLEEP */ #define CHANCE_OF_SLEEP (1000) /* JITTER_DELAY is denominated in microseconds (us) */ #define JITTER_DELAY (50000) /* 0.05 seconds */ /* NUM_COMMS is the number of communicators on which ops will be posted */ #define NUM_COMMS (4) /* Constants that control behavior of the individual testing operations. * Altering these can help to explore the testing space, but increasing them too * much can consume too much memory (often O(n^2) usage). */ /* FIXME is COUNT==10 too limiting? should we try a larger count too (~500)? */ #define COUNT (10) #define PRIME (17) #define my_assert(cond_) \ do { \ if (!(cond_)) { \ ++errs; \ if (errs < 10) { \ fprintf(stderr, "assertion (%s) failed on line %d\n", #cond_, __LINE__); \ } \ } \ } while (0) /* Since MPICH is currently the only NBC implementation in existence, just use * this quick-and-dirty #ifdef to decide whether to test the nonblocking * collectives. Eventually we can add a configure option or configure test, or * the MPI-3 standard will be released and these can be gated on a MPI_VERSION * check */ #if !defined(USE_STRICT_MPI) && defined(MPICH) #define TEST_NBC_ROUTINES 1 #endif #if defined(TEST_NBC_ROUTINES) /* Intended to act like "rand_r", but we can be sure that it will exist and be * consistent across all of comm world. Returns a number in the range * [0,GEN_PRN_MAX] */ #define GEN_PRN_MAX (4294967291-1) static unsigned int gen_prn(unsigned int x) { /* a simple "multiplicative congruential method" PRNG, with parameters: * m=4294967291, largest 32-bit prime * a=279470273, good primitive root of m from "TABLES OF LINEAR * CONGRUENTIAL GENERATORS OF DIFFERENT SIZES AND GOOD * LATTICE STRUCTURE", by Pierre L’Ecuyer */ return (279470273UL * (unsigned long)x) % 4294967291UL; } /* given a random unsigned int value "rndval_" from gen_prn, this evaluates to a * value in the range [min_,max_) */ #define rand_range(rndval_,min_,max_) \ ((unsigned int)((min_) + ((rndval_) * (1.0 / (GEN_PRN_MAX+1.0)) * ((max_) - (min_))))) static void sum_fn(void *invec, void *inoutvec, int *len, MPI_Datatype *datatype) { int i; int *in = invec; int *inout = inoutvec; for (i = 0; i < *len; ++i) { inout[i] = in[i] + inout[i]; } } /* used to keep track of buffers that should be freed after the corresponding * operation has completed */ struct laundry { int case_num; /* which test case initiated this req/laundry */ MPI_Comm comm; int *buf; int *recvbuf; int *sendcounts; int *recvcounts; int *sdispls; int *rdispls; int *sendtypes; int *recvtypes; }; static void cleanup_laundry(struct laundry *l) { l->case_num = -1; l->comm = MPI_COMM_NULL; if (l->buf) free(l->buf); if (l->recvbuf) free(l->recvbuf); if (l->sendcounts) free(l->sendcounts); if (l->recvcounts) free(l->recvcounts); if (l->sdispls) free(l->sdispls); if (l->rdispls) free(l->rdispls); if (l->sendtypes) free(l->sendtypes); if (l->recvtypes) free(l->recvtypes); } /* Starts a "random" operation on "comm" corresponding to "rndnum" and returns * in (*req) a request handle corresonding to that operation. This call should * be considered collective over comm (with a consistent value for "rndnum"), * even though the operation may only be a point-to-point request. */ static void start_random_nonblocking(MPI_Comm comm, unsigned int rndnum, MPI_Request *req, struct laundry *l) { int i, j; int rank, size; int *buf = NULL; int *recvbuf = NULL; int *sendcounts = NULL; int *recvcounts = NULL; int *sdispls = NULL; int *rdispls = NULL; int *sendtypes = NULL; int *recvtypes = NULL; char *buf_alias = NULL; MPI_Comm_rank(comm, &rank); MPI_Comm_size(comm, &size); *req = MPI_REQUEST_NULL; l->case_num = -1; l->comm = comm; l->buf = buf = malloc(COUNT*size*sizeof(int)); l->recvbuf = recvbuf = malloc(COUNT*size*sizeof(int)); l->sendcounts = sendcounts = malloc(size*sizeof(int)); l->recvcounts = recvcounts = malloc(size*sizeof(int)); l->sdispls = sdispls = malloc(size*sizeof(int)); l->rdispls = rdispls = malloc(size*sizeof(int)); l->sendtypes = sendtypes = malloc(size*sizeof(MPI_Datatype)); l->recvtypes = recvtypes = malloc(size*sizeof(MPI_Datatype)); #define NUM_CASES (21) l->case_num = rand_range(rndnum, 0, NUM_CASES); switch (l->case_num) { case 0: /* MPI_Ibcast */ for (i = 0; i < COUNT; ++i) { if (rank == 0) { buf[i] = i; } else { buf[i] = 0xdeadbeef; } } MPI_Ibcast(buf, COUNT, MPI_INT, 0, comm, req); break; case 1: /* MPI_Ibcast (again, but designed to stress scatter/allgather impls) */ /* FIXME fiddle with PRIME and buffer allocation s.t. PRIME is much larger (1021?) */ buf_alias = (char *)buf; my_assert(COUNT*size*sizeof(int) > PRIME); /* sanity */ for (i = 0; i < PRIME; ++i) { if (rank == 0) buf_alias[i] = i; else buf_alias[i] = 0xdb; } for (i = PRIME; i < COUNT * size * sizeof(int); ++i) { buf_alias[i] = 0xbf; } MPI_Ibcast(buf, PRIME, MPI_SIGNED_CHAR, 0, comm, req); break; case 2: /* MPI_Ibarrier */ MPI_Ibarrier(comm, req); break; case 3: /* MPI_Ireduce */ for (i = 0; i < COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Ireduce(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, 0, comm, req); break; case 4: /* same again, use a user op and free it before the wait */ { MPI_Op op = MPI_OP_NULL; MPI_Op_create(sum_fn, /*commute=*/1, &op); for (i = 0; i < COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Ireduce(buf, recvbuf, COUNT, MPI_INT, op, 0, comm, req); MPI_Op_free(&op); } break; case 5: /* MPI_Iallreduce */ for (i = 0; i < COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Iallreduce(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, comm, req); break; case 6: /* MPI_Ialltoallv (a weak test, neither irregular nor sparse) */ for (i = 0; i < size; ++i) { sendcounts[i] = COUNT; recvcounts[i] = COUNT; sdispls[i] = COUNT * i; rdispls[i] = COUNT * i; for (j = 0; j < COUNT; ++j) { buf[i*COUNT+j] = rank + (i * j); recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Ialltoallv(buf, sendcounts, sdispls, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT, comm, req); break; case 7: /* MPI_Igather */ for (i = 0; i < size*COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Igather(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, 0, comm, req); break; case 8: /* same test again, just use a dup'ed datatype and free it before the wait */ { MPI_Datatype type = MPI_DATATYPE_NULL; MPI_Type_dup(MPI_INT, &type); for (i = 0; i < size*COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Igather(buf, COUNT, MPI_INT, recvbuf, COUNT, type, 0, comm, req); MPI_Type_free(&type); /* should cause implementations that don't refcount correctly to blow up or hang in the wait */ } break; case 9: /* MPI_Iscatter */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { if (rank == 0) buf[i*COUNT+j] = i + j; else buf[i*COUNT+j] = 0xdeadbeef; recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Iscatter(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, 0, comm, req); break; case 10: /* MPI_Iscatterv */ for (i = 0; i < size; ++i) { /* weak test, just test the regular case where all counts are equal */ sendcounts[i] = COUNT; sdispls[i] = i * COUNT; for (j = 0; j < COUNT; ++j) { if (rank == 0) buf[i*COUNT+j] = i + j; else buf[i*COUNT+j] = 0xdeadbeef; recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Iscatterv(buf, sendcounts, sdispls, MPI_INT, recvbuf, COUNT, MPI_INT, 0, comm, req); break; case 11: /* MPI_Ireduce_scatter */ for (i = 0; i < size; ++i) { recvcounts[i] = COUNT; for (j = 0; j < COUNT; ++j) { buf[i*COUNT+j] = rank + i; recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Ireduce_scatter(buf, recvbuf, recvcounts, MPI_INT, MPI_SUM, comm, req); break; case 12: /* MPI_Ireduce_scatter_block */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { buf[i*COUNT+j] = rank + i; recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Ireduce_scatter_block(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, comm, req); break; case 13: /* MPI_Igatherv */ for (i = 0; i < size*COUNT; ++i) { buf[i] = 0xdeadbeef; recvbuf[i] = 0xdeadbeef; } for (i = 0; i < COUNT; ++i) { buf[i] = rank + i; } for (i = 0; i < size; ++i) { recvcounts[i] = COUNT; rdispls[i] = i * COUNT; } MPI_Igatherv(buf, COUNT, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT, 0, comm, req); break; case 14: /* MPI_Ialltoall */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { buf[i*COUNT+j] = rank + (i * j); recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Ialltoall(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, comm, req); break; case 15: /* MPI_Iallgather */ for (i = 0; i < size*COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Iallgather(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, comm, req); break; case 16: /* MPI_Iallgatherv */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { recvbuf[i*COUNT+j] = 0xdeadbeef; } recvcounts[i] = COUNT; rdispls[i] = i * COUNT; } for (i = 0; i < COUNT; ++i) buf[i] = rank + i; MPI_Iallgatherv(buf, COUNT, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT, comm, req); break; case 17: /* MPI_Iscan */ for (i = 0; i < COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Iscan(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, comm, req); break; case 18: /* MPI_Iexscan */ for (i = 0; i < COUNT; ++i) { buf[i] = rank + i; recvbuf[i] = 0xdeadbeef; } MPI_Iexscan(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, comm, req); break; case 19: /* MPI_Ialltoallw (a weak test, neither irregular nor sparse) */ for (i = 0; i < size; ++i) { sendcounts[i] = COUNT; recvcounts[i] = COUNT; sdispls[i] = COUNT * i * sizeof(int); rdispls[i] = COUNT * i * sizeof(int); sendtypes[i] = MPI_INT; recvtypes[i] = MPI_INT; for (j = 0; j < COUNT; ++j) { buf[i*COUNT+j] = rank + (i * j); recvbuf[i*COUNT+j] = 0xdeadbeef; } } MPI_Ialltoallw(buf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm, req); break; case 20: /* basic pt2pt MPI_Isend/MPI_Irecv pairing */ /* even ranks send to odd ranks, but only if we have a full pair */ if ((rank % 2 != 0) || (rank != size-1)) { for (j = 0; j < COUNT; ++j) { buf[j] = j; recvbuf[j] = 0xdeadbeef; } if (rank % 2 == 0) MPI_Isend(buf, COUNT, MPI_INT, rank+1, 5, comm, req); else MPI_Irecv(recvbuf, COUNT, MPI_INT, rank-1, 5, comm, req); } break; default: fprintf(stderr, "unexpected value for l->case_num=%d)\n", (l->case_num)); MPI_Abort(comm, 1); exit(1); break; } } static void check_after_completion(struct laundry *l) { int i, j; int rank, size; MPI_Comm comm = l->comm; int *buf = l->buf; int *recvbuf = l->recvbuf; int *sendcounts = l->sendcounts; int *recvcounts = l->recvcounts; int *sdispls = l->sdispls; int *rdispls = l->rdispls; int *sendtypes = l->sendtypes; int *recvtypes = l->recvtypes; char *buf_alias = (char *)buf; MPI_Comm_rank(comm, &rank); MPI_Comm_size(comm, &size); /* these cases all correspond to cases in start_random_nonblocking */ switch (l->case_num) { case 0: /* MPI_Ibcast */ for (i = 0; i < COUNT; ++i) { if (buf[i] != i) printf("buf[%d]=%d i=%d\n", i, buf[i], i); my_assert(buf[i] == i); } break; case 1: /* MPI_Ibcast (again, but designed to stress scatter/allgather impls) */ for (i = 0; i < PRIME; ++i) { if (buf_alias[i] != i) printf("buf_alias[%d]=%d i=%d\n", i, buf_alias[i], i); my_assert(buf_alias[i] == i); } break; case 2: /* MPI_Ibarrier */ /* nothing to check */ break; case 3: /* MPI_Ireduce */ if (rank == 0) { for (i = 0; i < COUNT; ++i) { if (recvbuf[i] != ((size * (size-1) / 2) + (i * size))) printf("got recvbuf[%d]=%d, expected %d\n", i, recvbuf[i], ((size * (size-1) / 2) + (i * size))); my_assert(recvbuf[i] == ((size * (size-1) / 2) + (i * size))); } } break; case 4: /* same again, use a user op and free it before the wait */ if (rank == 0) { for (i = 0; i < COUNT; ++i) { if (recvbuf[i] != ((size * (size-1) / 2) + (i * size))) printf("got recvbuf[%d]=%d, expected %d\n", i, recvbuf[i], ((size * (size-1) / 2) + (i * size))); my_assert(recvbuf[i] == ((size * (size-1) / 2) + (i * size))); } } break; case 5: /* MPI_Iallreduce */ for (i = 0; i < COUNT; ++i) { if (recvbuf[i] != ((size * (size-1) / 2) + (i * size))) printf("got recvbuf[%d]=%d, expected %d\n", i, recvbuf[i], ((size * (size-1) / 2) + (i * size))); my_assert(recvbuf[i] == ((size * (size-1) / 2) + (i * size))); } break; case 6: /* MPI_Ialltoallv (a weak test, neither irregular nor sparse) */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { /*printf("recvbuf[%d*COUNT+%d]=%d, expecting %d\n", i, j, recvbuf[i*COUNT+j], (i + (rank * j)));*/ my_assert(recvbuf[i*COUNT+j] == (i + (rank * j))); } } break; case 7: /* MPI_Igather */ if (rank == 0) { for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[i*COUNT+j] == i + j); } } } else { for (i = 0; i < size*COUNT; ++i) { my_assert(recvbuf[i] == 0xdeadbeef); } } break; case 8: /* same test again, just use a dup'ed datatype and free it before the wait */ if (rank == 0) { for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[i*COUNT+j] == i + j); } } } else { for (i = 0; i < size*COUNT; ++i) { my_assert(recvbuf[i] == 0xdeadbeef); } } break; case 9: /* MPI_Iscatter */ for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[j] == rank + j); } if (rank != 0) { for (i = 0; i < size*COUNT; ++i) { /* check we didn't corrupt the sendbuf somehow */ my_assert(buf[i] == 0xdeadbeef); } } break; case 10: /* MPI_Iscatterv */ for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[j] == rank + j); } if (rank != 0) { for (i = 0; i < size*COUNT; ++i) { /* check we didn't corrupt the sendbuf somehow */ my_assert(buf[i] == 0xdeadbeef); } } for (i = 1; i < size; ++i) { for (j = 0; j < COUNT; ++j) { /* check we didn't corrupt the rest of the recvbuf */ my_assert(recvbuf[i*COUNT+j] == 0xdeadbeef); } } break; case 11: /* MPI_Ireduce_scatter */ for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[j] == (size * rank + ((size - 1) * size) / 2)); } for (i = 1; i < size; ++i) { for (j = 0; j < COUNT; ++j) { /* check we didn't corrupt the rest of the recvbuf */ my_assert(recvbuf[i*COUNT+j] == 0xdeadbeef); } } break; case 12: /* MPI_Ireduce_scatter_block */ for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[j] == (size * rank + ((size - 1) * size) / 2)); } for (i = 1; i < size; ++i) { for (j = 0; j < COUNT; ++j) { /* check we didn't corrupt the rest of the recvbuf */ my_assert(recvbuf[i*COUNT+j] == 0xdeadbeef); } } break; case 13: /* MPI_Igatherv */ if (rank == 0) { for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[i*COUNT+j] == i + j); } } } else { for (i = 0; i < size*COUNT; ++i) { my_assert(recvbuf[i] == 0xdeadbeef); } } break; case 14: /* MPI_Ialltoall */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { /*printf("recvbuf[%d*COUNT+%d]=%d, expecting %d\n", i, j, recvbuf[i*COUNT+j], (i + (i * j)));*/ my_assert(recvbuf[i*COUNT+j] == (i + (rank * j))); } } break; case 15: /* MPI_Iallgather */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[i*COUNT+j] == i + j); } } break; case 16: /* MPI_Iallgatherv */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { my_assert(recvbuf[i*COUNT+j] == i + j); } } break; case 17: /* MPI_Iscan */ for (i = 0; i < COUNT; ++i) { my_assert(recvbuf[i] == ((rank * (rank+1) / 2) + (i * (rank + 1)))); } break; case 18: /* MPI_Iexscan */ for (i = 0; i < COUNT; ++i) { if (rank == 0) my_assert(recvbuf[i] == 0xdeadbeef); else my_assert(recvbuf[i] == ((rank * (rank+1) / 2) + (i * (rank + 1)) - (rank + i))); } break; case 19: /* MPI_Ialltoallw (a weak test, neither irregular nor sparse) */ for (i = 0; i < size; ++i) { for (j = 0; j < COUNT; ++j) { /*printf("recvbuf[%d*COUNT+%d]=%d, expecting %d\n", i, j, recvbuf[i*COUNT+j], (i + (rank * j)));*/ my_assert(recvbuf[i*COUNT+j] == (i + (rank * j))); } } break; case 20: /* basic pt2pt MPI_Isend/MPI_Irecv pairing */ /* even ranks send to odd ranks, but only if we have a full pair */ if ((rank % 2 != 0) || (rank != size-1)) { for (j = 0; j < COUNT; ++j) { /* only odd procs did a recv */ if (rank % 2 == 0) { my_assert(recvbuf[j] == 0xdeadbeef); } else { if (recvbuf[j] != j) printf("recvbuf[%d]=%d j=%d\n", j, recvbuf[j], j); my_assert(recvbuf[j] == j); } } } break; default: printf("invalid case_num (%d) detected\n", l->case_num); assert(0); break; } } #undef NUM_CASES static void complete_something_somehow(unsigned int rndnum, int numreqs, MPI_Request reqs[], int *outcount, int indices[]) { int i, idx, flag; #define COMPLETION_CASES (8) switch (rand_range(rndnum, 0, COMPLETION_CASES)) { case 0: MPI_Waitall(numreqs, reqs, MPI_STATUSES_IGNORE); *outcount = numreqs; for (i = 0; i < numreqs; ++i) { indices[i] = i; } break; case 1: MPI_Testsome(numreqs, reqs, outcount, indices, MPI_STATUS_IGNORE); if (*outcount == MPI_UNDEFINED) { *outcount = 0; } break; case 2: MPI_Waitsome(numreqs, reqs, outcount, indices, MPI_STATUS_IGNORE); if (*outcount == MPI_UNDEFINED) { *outcount = 0; } break; case 3: MPI_Waitany(numreqs, reqs, &idx, MPI_STATUS_IGNORE); if (idx == MPI_UNDEFINED) { *outcount = 0; } else { *outcount = 1; indices[0] = idx; } break; case 4: MPI_Testany(numreqs, reqs, &idx, &flag, MPI_STATUS_IGNORE); if (idx == MPI_UNDEFINED) { *outcount = 0; } else { *outcount = 1; indices[0] = idx; } break; case 5: MPI_Testall(numreqs, reqs, &flag, MPI_STATUSES_IGNORE); if (flag) { *outcount = numreqs; for (i = 0; i < numreqs; ++i) { indices[i] = i; } } else { *outcount = 0; } break; case 6: /* select a new random index and wait on it */ rndnum = gen_prn(rndnum); idx = rand_range(rndnum, 0, numreqs); MPI_Wait(&reqs[idx], MPI_STATUS_IGNORE); *outcount = 1; indices[0] = idx; break; case 7: /* select a new random index and wait on it */ rndnum = gen_prn(rndnum); idx = rand_range(rndnum, 0, numreqs); MPI_Test(&reqs[idx], &flag, MPI_STATUS_IGNORE); *outcount = (flag ? 1 : 0); indices[0] = idx; break; default: assert(0); break; } #undef COMPLETION_CASES } #endif /* defined(TEST_NBC_ROUTINES) */ int main(int argc, char **argv) { int wrank, wsize; #if defined(TEST_NBC_ROUTINES) int i, num_posted, num_completed; unsigned int seed = 0x10bc; unsigned int post_seq, complete_seq; struct laundry larr[WINDOW]; MPI_Request reqs[WINDOW]; int outcount; int indices[WINDOW]; MPI_Comm comms[NUM_COMMS]; MPI_Comm comm; #endif MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &wrank); MPI_Comm_size(MPI_COMM_WORLD, &wsize); #if defined(TEST_NBC_ROUTINES) /* it is critical that all processes in the communicator start with a * consistent value for "post_seq" */ post_seq = complete_seq = gen_prn(seed); num_completed = 0; num_posted = 0; /* construct all of the communicators, just dups of comm world for now */ for (i = 0; i < NUM_COMMS; ++i) { MPI_Comm_dup(MPI_COMM_WORLD, &comms[i]); } /* fill the entire window of ops */ for (i = 0; i < WINDOW; ++i) { reqs[i] = MPI_REQUEST_NULL; memset(&larr[i], 0, sizeof(struct laundry)); larr[i].case_num = -1; /* randomly select a comm, using a new seed to avoid correlating * particular kinds of NBC ops with particular communicators */ comm = comms[rand_range(gen_prn(post_seq), 0, NUM_COMMS)]; start_random_nonblocking(comm, post_seq, &reqs[i], &larr[i]); ++num_posted; post_seq = gen_prn(post_seq); } /* now loop repeatedly, completing ops with "random" completion functions, * until we've posted and completed MAIN_ITERATIONS ops */ while (num_completed < MAIN_ITERATIONS) { complete_something_somehow(complete_seq, WINDOW, reqs, &outcount, indices); complete_seq = gen_prn(complete_seq); for (i = 0; i < outcount; ++i) { int idx = indices[i]; assert(reqs[idx] == MPI_REQUEST_NULL); if (larr[idx].case_num != -1) { check_after_completion(&larr[idx]); cleanup_laundry(&larr[idx]); ++num_completed; if (num_posted < MAIN_ITERATIONS) { comm = comms[rand_range(gen_prn(post_seq), 0, NUM_COMMS)]; start_random_nonblocking(comm, post_seq, &reqs[idx], &larr[idx]); ++num_posted; post_seq = gen_prn(post_seq); } } } /* "randomly" and infrequently introduce some jitter into the system */ if (0 == rand_range(gen_prn(complete_seq + wrank), 0, CHANCE_OF_SLEEP)) { usleep(JITTER_DELAY); /* take a short nap */ } } for (i = 0; i < NUM_COMMS; ++i) { MPI_Comm_free(&comms[i]); } #endif /* defined(TEST_NBC_ROUTINES) */ if (wrank == 0) { if (errs) printf("found %d errors\n", errs); else printf(" No errors\n"); } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/allred.c000644 001750 001750 00000050073 12342443661 021523 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* Warning - this test will fail for MPI_PROD & maybe MPI_SUM * if more than 10 MPI processes are used. Loss of precision * will occur as the number of processors is increased. */ #include "mpi.h" #include "mpitest.h" #include #include #include #ifdef HAVE_STDINT_H #include #endif int count, size, rank; int cerrcnt; struct int_test { int a; int b; }; struct long_test { long a; int b; }; struct short_test { short a; int b; }; struct float_test { float a; int b; }; struct double_test { double a; int b; }; #define mpi_op2str(op) \ ((op == MPI_SUM) ? "MPI_SUM" : \ (op == MPI_PROD) ? "MPI_PROD" : \ (op == MPI_MAX) ? "MPI_MAX" : \ (op == MPI_MIN) ? "MPI_MIN" : \ (op == MPI_LOR) ? "MPI_LOR" : \ (op == MPI_LXOR) ? "MPI_LXOR" : \ (op == MPI_LAND) ? "MPI_LAND" : \ (op == MPI_BOR) ? "MPI_BOR" : \ (op == MPI_BAND) ? "MPI_BAND" : \ (op == MPI_BXOR) ? "MPI_BXOR" : \ (op == MPI_MAXLOC) ? "MPI_MAXLOC" : \ (op == MPI_MINLOC) ? "MPI_MINLOC" : \ "MPI_NO_OP") /* calloc to avoid spurious valgrind warnings when "type" has padding bytes */ #define DECL_MALLOC_IN_OUT_SOL(type) \ type *in, *out, *sol; \ in = (type *) calloc(count, sizeof(type)); \ out = (type *) calloc(count, sizeof(type)); \ sol = (type *) calloc(count, sizeof(type)); #define SET_INDEX_CONST(arr, val) \ { \ int i; \ for (i = 0; i < count; i++) \ arr[i] = val; \ } #define SET_INDEX_SUM(arr, val) \ { \ int i; \ for (i = 0; i < count; i++) \ arr[i] = i + val; \ } #define SET_INDEX_FACTOR(arr, val) \ { \ int i; \ for (i = 0; i < count; i++) \ arr[i] = i * (val); \ } #define SET_INDEX_POWER(arr, val) \ { \ int i, j; \ for (i = 0; i < count; i++) { \ (arr)[i] = 1; \ for (j = 0; j < (val); j++) \ arr[i] *= i; \ } \ } #define ERROR_CHECK_AND_FREE(lerrcnt, mpi_type, mpi_op) \ do { \ char name[MPI_MAX_OBJECT_NAME] = {0}; \ int len = 0; \ if (lerrcnt) { \ MPI_Type_get_name(mpi_type, name, &len); \ fprintf(stderr, "(%d) Error for type %s and op %s\n", \ rank, name, mpi_op2str(mpi_op)); \ } \ free(in); free(out); free(sol); \ } while(0) /* The logic on the error check on MPI_Allreduce assumes that all MPI_Allreduce routines return a failure if any do - this is sufficient for MPI implementations that reject some of the valid op/datatype pairs (and motivated this addition, as some versions of the IBM MPI failed in just this way). */ #define ALLREDUCE_AND_FREE(mpi_type, mpi_op, in, out, sol) \ { \ int i, rc, lerrcnt = 0; \ rc = MPI_Allreduce(in, out, count, mpi_type, mpi_op, MPI_COMM_WORLD); \ if (rc) { lerrcnt++; cerrcnt++; MTestPrintError( rc ); } \ else { \ for (i = 0; i < count; i++) { \ if (out[i] != sol[i]) { \ cerrcnt++; \ lerrcnt++; \ } \ } \ } \ ERROR_CHECK_AND_FREE(lerrcnt, mpi_type, mpi_op); \ } #define STRUCT_ALLREDUCE_AND_FREE(mpi_type, mpi_op, in, out, sol) \ { \ int i, rc, lerrcnt = 0; \ rc = MPI_Allreduce(in, out, count, mpi_type, mpi_op, MPI_COMM_WORLD); \ if (rc) { lerrcnt++; cerrcnt++; MTestPrintError( rc ); } \ else { \ for (i = 0; i < count; i++) { \ if ((out[i].a != sol[i].a) || (out[i].b != sol[i].b)) { \ cerrcnt++; \ lerrcnt++; \ } \ } \ } \ ERROR_CHECK_AND_FREE(lerrcnt, mpi_type, mpi_op); \ } #define SET_INDEX_STRUCT_CONST(arr, val, el) \ { \ int i; \ for (i = 0; i < count; i++) \ arr[i].el = val; \ } #define SET_INDEX_STRUCT_SUM(arr, val, el) \ { \ int i; \ for (i = 0; i < count; i++) \ arr[i].el = i + (val); \ } #define sum_test1(type, mpi_type) \ { \ DECL_MALLOC_IN_OUT_SOL(type); \ SET_INDEX_SUM(in, 0); \ SET_INDEX_FACTOR(sol, size); \ SET_INDEX_CONST(out, 0); \ ALLREDUCE_AND_FREE(mpi_type, MPI_SUM, in, out, sol); \ } #define prod_test1(type, mpi_type) \ { \ DECL_MALLOC_IN_OUT_SOL(type); \ SET_INDEX_SUM(in, 0); \ SET_INDEX_POWER(sol, size); \ SET_INDEX_CONST(out, 0); \ ALLREDUCE_AND_FREE(mpi_type, MPI_PROD, in, out, sol); \ } #define max_test1(type, mpi_type) \ { \ DECL_MALLOC_IN_OUT_SOL(type); \ SET_INDEX_SUM(in, rank); \ SET_INDEX_SUM(sol, size - 1); \ SET_INDEX_CONST(out, 0); \ ALLREDUCE_AND_FREE(mpi_type, MPI_MAX, in, out, sol); \ } #define min_test1(type, mpi_type) \ { \ DECL_MALLOC_IN_OUT_SOL(type); \ SET_INDEX_SUM(in, rank); \ SET_INDEX_SUM(sol, 0); \ SET_INDEX_CONST(out, 0); \ ALLREDUCE_AND_FREE(mpi_type, MPI_MIN, in, out, sol); \ } #define const_test(type, mpi_type, mpi_op, val1, val2, val3) \ { \ DECL_MALLOC_IN_OUT_SOL(type); \ SET_INDEX_CONST(in, (val1)); \ SET_INDEX_CONST(sol, (val2)); \ SET_INDEX_CONST(out, (val3)); \ ALLREDUCE_AND_FREE(mpi_type, mpi_op, in, out, sol); \ } #define lor_test1(type, mpi_type) \ const_test(type, mpi_type, MPI_LOR, (rank & 0x1), (size > 1), 0) #define lor_test2(type, mpi_type) \ const_test(type, mpi_type, MPI_LOR, 0, 0, 0) #define lxor_test1(type, mpi_type) \ const_test(type, mpi_type, MPI_LXOR, (rank == 1), (size > 1), 0) #define lxor_test2(type, mpi_type) \ const_test(type, mpi_type, MPI_LXOR, 0, 0, 0) #define lxor_test3(type, mpi_type) \ const_test(type, mpi_type, MPI_LXOR, 1, (size & 0x1), 0) #define land_test1(type, mpi_type) \ const_test(type, mpi_type, MPI_LAND, (rank & 0x1), 0, 0) #define land_test2(type, mpi_type) \ const_test(type, mpi_type, MPI_LAND, 1, 1, 0) #define bor_test1(type, mpi_type) \ const_test(type, mpi_type, MPI_BOR, (rank & 0x3), ((size < 3) ? size - 1 : 0x3), 0) #define bxor_test1(type, mpi_type) \ const_test(type, mpi_type, MPI_BXOR, (rank == 1) * 0xf0, (size > 1) * 0xf0, 0) #define bxor_test2(type, mpi_type) \ const_test(type, mpi_type, MPI_BXOR, 0, 0, 0) #define bxor_test3(type, mpi_type) \ const_test(type, mpi_type, MPI_BXOR, ~0, (size &0x1) ? ~0 : 0, 0) #define band_test1(type, mpi_type) \ { \ DECL_MALLOC_IN_OUT_SOL(type); \ if (rank == size-1) { \ SET_INDEX_SUM(in, 0); \ } \ else { \ SET_INDEX_CONST(in, ~0); \ } \ SET_INDEX_SUM(sol, 0); \ SET_INDEX_CONST(out, 0); \ ALLREDUCE_AND_FREE(mpi_type, MPI_BAND, in, out, sol); \ } #define band_test2(type, mpi_type) \ { \ DECL_MALLOC_IN_OUT_SOL(type); \ if (rank == size-1) { \ SET_INDEX_SUM(in, 0); \ } \ else { \ SET_INDEX_CONST(in, 0); \ } \ SET_INDEX_CONST(sol, 0); \ SET_INDEX_CONST(out, 0); \ ALLREDUCE_AND_FREE(mpi_type, MPI_BAND, in, out, sol); \ } #define maxloc_test(type, mpi_type) \ { \ DECL_MALLOC_IN_OUT_SOL(type); \ SET_INDEX_STRUCT_SUM(in, rank, a); \ SET_INDEX_STRUCT_CONST(in, rank, b); \ SET_INDEX_STRUCT_SUM(sol, size - 1, a); \ SET_INDEX_STRUCT_CONST(sol, size - 1, b); \ SET_INDEX_STRUCT_CONST(out, 0, a); \ SET_INDEX_STRUCT_CONST(out, -1, b); \ STRUCT_ALLREDUCE_AND_FREE(mpi_type, MPI_MAXLOC, in, out, sol); \ } #define minloc_test(type, mpi_type) \ { \ DECL_MALLOC_IN_OUT_SOL(type); \ SET_INDEX_STRUCT_SUM(in, rank, a); \ SET_INDEX_STRUCT_CONST(in, rank, b); \ SET_INDEX_STRUCT_SUM(sol, 0, a); \ SET_INDEX_STRUCT_CONST(sol, 0, b); \ SET_INDEX_STRUCT_CONST(out, 0, a); \ SET_INDEX_STRUCT_CONST(out, -1, b); \ STRUCT_ALLREDUCE_AND_FREE(mpi_type, MPI_MINLOC, in, out, sol); \ } #if MTEST_HAVE_MIN_MPI_VERSION(2,2) #define test_types_set_mpi_2_2_integer(op,post) do { \ op##_test##post(int8_t, MPI_INT8_T); \ op##_test##post(int16_t, MPI_INT16_T); \ op##_test##post(int32_t, MPI_INT32_T); \ op##_test##post(int64_t, MPI_INT64_T); \ op##_test##post(uint8_t, MPI_UINT8_T); \ op##_test##post(uint16_t, MPI_UINT16_T); \ op##_test##post(uint32_t, MPI_UINT32_T); \ op##_test##post(uint64_t, MPI_UINT64_T); \ op##_test##post(MPI_Aint, MPI_AINT); \ op##_test##post(MPI_Offset, MPI_OFFSET); \ } while (0) #else #define test_types_set_mpi_2_2_integer(op,post) do { } while (0) #endif #if MTEST_HAVE_MIN_MPI_VERSION(3,0) #define test_types_set_mpi_3_0_integer(op,post) do { \ op##_test##post(MPI_Count, MPI_COUNT); \ } while (0) #else #define test_types_set_mpi_3_0_integer(op,post) do { } while (0) #endif #define test_types_set1(op, post) \ { \ op##_test##post(int, MPI_INT); \ op##_test##post(long, MPI_LONG); \ op##_test##post(short, MPI_SHORT); \ op##_test##post(unsigned short, MPI_UNSIGNED_SHORT); \ op##_test##post(unsigned, MPI_UNSIGNED); \ op##_test##post(unsigned long, MPI_UNSIGNED_LONG); \ op##_test##post(unsigned char, MPI_UNSIGNED_CHAR); \ test_types_set_mpi_2_2_integer(op,post); \ test_types_set_mpi_3_0_integer(op,post); \ } #define test_types_set2(op, post) \ { \ test_types_set1(op, post); \ op##_test##post(float, MPI_FLOAT); \ op##_test##post(double, MPI_DOUBLE); \ } #define test_types_set3(op, post) \ { \ op##_test##post(unsigned char, MPI_BYTE); \ } /* Make sure that we test complex and double complex, even if long double complex is not available */ #if defined(USE_LONG_DOUBLE_COMPLEX) #if MTEST_HAVE_MIN_MPI_VERSION(2,2) && defined(HAVE_FLOAT__COMPLEX) \ && defined(HAVE_DOUBLE__COMPLEX) \ && defined(HAVE_LONG_DOUBLE__COMPLEX) #define test_types_set4(op, post) \ do { \ op##_test##post(float _Complex, MPI_C_FLOAT_COMPLEX); \ op##_test##post(double _Complex, MPI_C_DOUBLE_COMPLEX); \ if (MPI_C_LONG_DOUBLE_COMPLEX != MPI_DATATYPE_NULL) { \ op##_test##post(long double _Complex, MPI_C_LONG_DOUBLE_COMPLEX); \ } \ } while (0) #else #define test_types_set4(op, post) do { } while (0) #endif #else #if MTEST_HAVE_MIN_MPI_VERSION(2,2) && defined(HAVE_FLOAT__COMPLEX) \ && defined(HAVE_DOUBLE__COMPLEX) #define test_types_set4(op, post) \ do { \ op##_test##post(float _Complex, MPI_C_FLOAT_COMPLEX); \ op##_test##post(double _Complex, MPI_C_DOUBLE_COMPLEX); \ } while (0) #else #define test_types_set4(op, post) do { } while (0) #endif #endif /* defined(USE_LONG_DOUBLE_COMPLEX) */ #if MTEST_HAVE_MIN_MPI_VERSION(2,2) && defined(HAVE__BOOL) #define test_types_set5(op, post) \ do { \ op##_test##post(_Bool, MPI_C_BOOL); \ } while (0) #else #define test_types_set5(op, post) do { } while (0) #endif int main( int argc, char **argv ) { MTest_Init( &argc, &argv ); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (size < 2) { fprintf( stderr, "At least 2 processes required\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } /* Set errors return so that we can provide better information should a routine reject one of the operand/datatype pairs */ MPI_Errhandler_set( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); count = 10; /* Allow an argument to override the count. Note that the product tests may fail if the count is very large. */ if (argc >= 2) { count = atoi( argv[1] ); if (count <= 0) { fprintf( stderr, "Invalid count argument %s\n", argv[1] ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } } test_types_set2(sum, 1); test_types_set2(prod, 1); test_types_set2(max, 1); test_types_set2(min, 1); test_types_set1(lor, 1); test_types_set1(lor, 2); test_types_set1(lxor, 1); test_types_set1(lxor, 2); test_types_set1(lxor, 3); test_types_set1(land, 1); test_types_set1(land, 2); test_types_set1(bor, 1); test_types_set1(band, 1); test_types_set1(band, 2); test_types_set1(bxor, 1); test_types_set1(bxor, 2); test_types_set1(bxor, 3); test_types_set3(bor, 1); test_types_set3(band, 1); test_types_set3(band, 2); test_types_set3(bxor, 1); test_types_set3(bxor, 2); test_types_set3(bxor, 3); test_types_set4(sum, 1); test_types_set4(prod, 1); test_types_set5(lor, 1); test_types_set5(lor, 2); test_types_set5(lxor, 1); test_types_set5(lxor, 2); test_types_set5(lxor, 3); test_types_set5(land, 1); test_types_set5(land, 2); maxloc_test(struct int_test, MPI_2INT); maxloc_test(struct long_test, MPI_LONG_INT); maxloc_test(struct short_test, MPI_SHORT_INT); maxloc_test(struct float_test, MPI_FLOAT_INT); maxloc_test(struct double_test, MPI_DOUBLE_INT); minloc_test(struct int_test, MPI_2INT); minloc_test(struct long_test, MPI_LONG_INT); minloc_test(struct short_test, MPI_SHORT_INT); minloc_test(struct float_test, MPI_FLOAT_INT); minloc_test(struct double_test, MPI_DOUBLE_INT); MPI_Errhandler_set( MPI_COMM_WORLD, MPI_ERRORS_ARE_FATAL ); MTest_Finalize( cerrcnt ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/opprod.c000644 001750 001750 00000020364 12342443661 021563 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitestconf.h" #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_PROD operations on optional datatypes dupported by MPICH"; */ typedef struct { double r, i; } d_complex; #ifdef HAVE_LONG_DOUBLE typedef struct { long double r, i; } ld_complex; #endif /* * This test looks at the handling of logical and for types that are not * integers or are not required integers (e.g., long long). MPICH allows * these as well. A strict MPI test should not include this test. */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size, maxsize, result[6] = { 1, 1, 2, 6, 24, 120 }; MPI_Comm comm; char cinbuf[3], coutbuf[3]; signed char scinbuf[3], scoutbuf[3]; unsigned char ucinbuf[3], ucoutbuf[3]; d_complex dinbuf[3], doutbuf[3]; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); if (size > 5) maxsize = 5; else maxsize = size; /* General forumula: If we multiple the values from 1 to n, the product is n!. This grows very fast, so we'll only use the first five (1! = 1, 2! = 2, 3! = 6, 4! = 24, 5! = 120), with n! stored in the array result[n] */ #ifndef USE_STRICT_MPI /* char */ MTestPrintfMsg( 10, "Reduce of MPI_CHAR\n" ); cinbuf[0] = (rank < maxsize && rank > 0) ? rank : 1; cinbuf[1] = 0; cinbuf[2] = (rank > 1); coutbuf[0] = 0; coutbuf[1] = 1; coutbuf[2] = 1; MPI_Reduce( cinbuf, coutbuf, 3, MPI_CHAR, MPI_PROD, 0, comm ); if (rank == 0) { if (coutbuf[0] != (char)result[maxsize-1]) { errs++; fprintf( stderr, "char PROD(rank) test failed (%d!=%d)\n", (int)coutbuf[0], (int)result[maxsize]); } if (coutbuf[1]) { errs++; fprintf( stderr, "char PROD(0) test failed\n" ); } if (size > 1 && coutbuf[2]) { errs++; fprintf( stderr, "char PROD(>) test failed\n" ); } } #endif /* USE_STRICT_MPI */ /* signed char */ MTestPrintfMsg( 10, "Reduce of MPI_SIGNED_CHAR\n" ); scinbuf[0] = (rank < maxsize && rank > 0) ? rank : 1; scinbuf[1] = 0; scinbuf[2] = (rank > 1); scoutbuf[0] = 0; scoutbuf[1] = 1; scoutbuf[2] = 1; MPI_Reduce( scinbuf, scoutbuf, 3, MPI_SIGNED_CHAR, MPI_PROD, 0, comm ); if (rank == 0) { if (scoutbuf[0] != (signed char)result[maxsize-1]) { errs++; fprintf( stderr, "signed char PROD(rank) test failed (%d!=%d)\n", (int)scoutbuf[0], (int)result[maxsize]); } if (scoutbuf[1]) { errs++; fprintf( stderr, "signed char PROD(0) test failed\n" ); } if (size > 1 && scoutbuf[2]) { errs++; fprintf( stderr, "signed char PROD(>) test failed\n" ); } } /* unsigned char */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_CHAR\n" ); ucinbuf[0] = (rank < maxsize && rank > 0) ? rank : 1; ucinbuf[1] = 0; ucinbuf[2] = (rank > 0); ucoutbuf[0] = 0; ucoutbuf[1] = 1; ucoutbuf[2] = 1; MPI_Reduce( ucinbuf, ucoutbuf, 3, MPI_UNSIGNED_CHAR, MPI_PROD, 0, comm ); if (rank == 0) { if (ucoutbuf[0] != (unsigned char)result[maxsize-1]) { errs++; fprintf( stderr, "unsigned char PROD(rank) test failed\n" ); } if (ucoutbuf[1]) { errs++; fprintf( stderr, "unsigned char PROD(0) test failed\n" ); } if (size > 1 && ucoutbuf[2]) { errs++; fprintf( stderr, "unsigned char PROD(>) test failed\n" ); } } #ifndef USE_STRICT_MPI /* For some reason, complex is not allowed for sum and prod */ if (MPI_DOUBLE_COMPLEX != MPI_DATATYPE_NULL) { int dc; #ifdef HAVE_LONG_DOUBLE ld_complex ldinbuf[3], ldoutbuf[3]; #endif /* Must determine which C type matches this Fortran type */ MPI_Type_size( MPI_DOUBLE_COMPLEX, &dc ); if (dc == sizeof(d_complex)) { /* double complex; may be null if we do not have Fortran support */ dinbuf[0].r = (rank < maxsize && rank > 0) ? rank : 1; dinbuf[1].r = 0; dinbuf[2].r = (rank > 0); dinbuf[0].i = 0; dinbuf[1].i = 1; dinbuf[2].i = -(rank > 0); doutbuf[0].r = 0; doutbuf[1].r = 1; doutbuf[2].r = 1; doutbuf[0].i = 0; doutbuf[1].i = 1; doutbuf[2].i = 1; MPI_Reduce( dinbuf, doutbuf, 3, MPI_DOUBLE_COMPLEX, MPI_PROD, 0, comm ); if (rank == 0) { double imag, real; if (doutbuf[0].r != (double)result[maxsize-1] || doutbuf[0].i != 0) { errs++; fprintf( stderr, "double complex PROD(rank) test failed\n" ); } /* Multiplying the imaginary part depends on size mod 4 */ imag = 1.0; real = 0.0; /* Make compiler happy */ switch (size % 4) { case 1: imag = 1.0; real = 0.0; break; case 2: imag = 0.0; real = -1.0; break; case 3: imag =-1.0; real = 0.0; break; case 0: imag = 0.0; real = 1.0; break; } if (doutbuf[1].r != real || doutbuf[1].i != imag) { errs++; fprintf( stderr, "double complex PROD(i) test failed (%f,%f)!=(%f,%f)\n", doutbuf[1].r,doutbuf[1].i,real,imag); } if (doutbuf[2].r != 0 || doutbuf[2].i != 0) { errs++; fprintf( stderr, "double complex PROD(>) test failed\n" ); } } } #ifdef HAVE_LONG_DOUBLE else if (dc == sizeof(ld_complex)) { /* double complex; may be null if we do not have Fortran support */ ldinbuf[0].r = (rank < maxsize && rank > 0) ? rank : 1; ldinbuf[1].r = 0; ldinbuf[2].r = (rank > 0); ldinbuf[0].i = 0; ldinbuf[1].i = 1; ldinbuf[2].i = -(rank > 0); ldoutbuf[0].r = 0; ldoutbuf[1].r = 1; ldoutbuf[2].r = 1; ldoutbuf[0].i = 0; ldoutbuf[1].i = 1; ldoutbuf[2].i = 1; MPI_Reduce( ldinbuf, ldoutbuf, 3, MPI_DOUBLE_COMPLEX, MPI_PROD, 0, comm ); if (rank == 0) { long double imag, real; if (ldoutbuf[0].r != (double)result[maxsize-1] || ldoutbuf[0].i != 0) { errs++; fprintf( stderr, "double complex PROD(rank) test failed\n" ); } /* Multiplying the imaginary part depends on size mod 4 */ imag = 1.0; real = 0.0; /* Make compiler happy */ switch (size % 4) { case 1: imag = 1.0; real = 0.0; break; case 2: imag = 0.0; real = -1.0; break; case 3: imag =-1.0; real = 0.0; break; case 0: imag = 0.0; real = 1.0; break; } if (ldoutbuf[1].r != real || ldoutbuf[1].i != imag) { errs++; fprintf( stderr, "double complex PROD(i) test failed (%Lf,%Lf)!=(%Lf,%Lf)\n", ldoutbuf[1].r,ldoutbuf[1].i,real,imag); } if (ldoutbuf[2].r != 0 || ldoutbuf[2].i != 0) { errs++; fprintf( stderr, "double complex PROD(>) test failed\n" ); } } } #endif /* HAVE_LONG_DOUBLE */ } #endif /* USE_STRICT_MPI */ #ifdef HAVE_LONG_DOUBLE { long double ldinbuf[3], ldoutbuf[3]; /* long double */ ldinbuf[0] = (rank < maxsize && rank > 0) ? rank : 1; ldinbuf[1] = 0; ldinbuf[2] = (rank > 0); ldoutbuf[0] = 0; ldoutbuf[1] = 1; ldoutbuf[2] = 1; if (MPI_LONG_DOUBLE != MPI_DATATYPE_NULL) { MPI_Reduce( ldinbuf, ldoutbuf, 3, MPI_LONG_DOUBLE, MPI_PROD, 0, comm ); if (rank == 0) { if (ldoutbuf[0] != (long double)result[maxsize-1]) { errs++; fprintf( stderr, "long double PROD(rank) test failed\n" ); } if (ldoutbuf[1]) { errs++; fprintf( stderr, "long double PROD(0) test failed\n" ); } if (size > 1 && ldoutbuf[2] != 0) { errs++; fprintf( stderr, "long double PROD(>) test failed\n" ); } } } } #endif /* HAVE_LONG_DOUBLE */ #ifdef HAVE_LONG_LONG { long long llinbuf[3], lloutbuf[3]; /* long long */ llinbuf[0] = (rank < maxsize && rank > 0) ? rank : 1; llinbuf[1] = 0; llinbuf[2] = (rank > 0); lloutbuf[0] = 0; lloutbuf[1] = 1; lloutbuf[2] = 1; if (MPI_LONG_LONG != MPI_DATATYPE_NULL) { MPI_Reduce( llinbuf, lloutbuf, 3, MPI_LONG_LONG, MPI_PROD, 0, comm ); if (rank == 0) { if (lloutbuf[0] != (long long)result[maxsize-1]) { errs++; fprintf( stderr, "long long PROD(rank) test failed\n" ); } if (lloutbuf[1]) { errs++; fprintf( stderr, "long long PROD(0) test failed\n" ); } if (size > 1 && lloutbuf[2]) { errs++; fprintf( stderr, "long long PROD(>) test failed\n" ); } } } } #endif /* HAVE_LONG_LONG */ MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/icalltoall.c000644 001750 001750 00000003714 12342443661 022400 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple intercomm alltoall test"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int *sendbuf = 0, *recvbuf = 0; int leftGroup, i, j, idx, count, rrank, rsize; MPI_Comm comm; MPI_Datatype datatype; MTest_Init( &argc, &argv ); datatype = MPI_INT; while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; for (count = 1; count < 66000; count = 2 * count) { /* Get an intercommunicator */ MPI_Comm_remote_size( comm, &rsize ); MPI_Comm_rank( comm, &rrank ); sendbuf = (int *)malloc( rsize * count * sizeof(int) ); recvbuf = (int *)malloc( rsize * count * sizeof(int) ); for (i=0; i #include #include "mpitest.h" #include /* static char MTEST_Descrip[] = "Test MPI_Allreduce with non-commutative user-defined operations using matrix rotations"; */ /* This example is similar to allred3.c, but uses only 3x3 matrics with integer-valued entries. This is an associative but not commutative operation. The number of matrices is the count argument. The matrix is stored in C order, so that c(i,j) is cin[j+i*3] Three different matrices are used: I = identity matrix A = (1 0 0 B = (0 1 0 0 0 1 1 0 0 0 1 0) 0 0 1) The product I^k A I^(p-2-k-j) B I^j is ( 0 1 0 0 0 1 1 0 0 ) for all values of k, p, and j. */ void matmult( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype ); void matmult( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype ) { const int *cin = (const int *)cinPtr; int *cout = (int *)coutPtr; int i, j, k, nmat; int tempcol[3]; int offset1, offset2; for (nmat = 0; nmat < *count; nmat++) { for (j=0; j<3; j++) { for (i=0; i<3; i++) { tempcol[i] = 0; for (k=0; k<3; k++) { /* col[i] += cin(i,k) * cout(k,j) */ offset1 = k+i*3; offset2 = j+k*3; tempcol[i] += cin[offset1] * cout[offset2]; } } for (i=0; i<3; i++) { offset1 = j+i*3; cout[offset1] = tempcol[i]; } } /* Advance to the next matrix */ cin += 9; cout += 9; } } /* Initialize the integer matrix as one of the above matrix entries, as a function of count. We guarantee that both the A and B matrices are included. */ static void initMat( int rank, int size, int nmat, int mat[] ) { int i, kind; /* Zero the matrix */ for (i=0; i<9; i++) { mat[i] = 0; } /* Decide which matrix to create (I, A, or B) */ if ( size == 2) { /* rank 0 is A, 1 is B */ kind = 1 + rank; } else { int tmpA, tmpB; /* Most ranks are identity matrices */ kind = 0; /* Make sure exactly one rank gets the A matrix and one the B matrix */ tmpA = size / 4; tmpB = (3 * size) / 4; if (rank == tmpA) kind = 1; if (rank == tmpB) kind = 2; } switch (kind) { case 0: /* Identity */ mat[0] = 1; mat[4] = 1; mat[8] = 1; break; case 1: /* A */ mat[0] = 1; mat[5] = 1; mat[7] = 1; break; case 2: /* B */ mat[1] = 1; mat[3] = 1; mat[8] = 1; break; } } /* Compare a matrix with the known result */ static int checkResult( int nmat, int mat[], const char *msg ) { int n, k, errs = 0, wrank; static int solution[9] = { 0, 1, 0, 0, 0, 1, 1, 0, 0 }; MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); for (n=0; n #include #include /* This program tests MPI_Alltoallw by having processor i send different amounts of data to each processor. This is just the MPI_Alltoallv test, but with displacements in bytes rather than units of the datatype. Because there are separate send and receive types to alltoallw, there need to be tests to rearrange data on the fly. Not done yet. The first test sends i items to processor i from all processors. Currently, the test uses only MPI_INT; this is adequate for testing systems that use point-to-point operations */ int main( int argc, char **argv ) { MPI_Comm comm; int *sbuf, *rbuf; int rank, size; int *sendcounts, *recvcounts, *rdispls, *sdispls; int i, j, *p, err; MPI_Datatype *sendtypes, *recvtypes; MTest_Init( &argc, &argv ); err = 0; while (MTestGetIntracommGeneral( &comm, 2, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Create the buffer */ MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); sbuf = (int *)malloc( size * size * sizeof(int) ); rbuf = (int *)malloc( size * size * sizeof(int) ); if (!sbuf || !rbuf) { fprintf( stderr, "Could not allocated buffers!\n" ); MPI_Abort( comm, 1 ); exit(1); } /* Load up the buffers */ for (i=0; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "A simple test of MPI_Reduce_local"; */ #define MAX_BUF_ELEMENTS (65000) static int uop_errs = 0; /* prototype to keep the compiler happy */ static void user_op(void *invec, void *inoutvec, int *len, MPI_Datatype *datatype); static void user_op(void *invec, void *inoutvec, int *len, MPI_Datatype *datatype) { int i; int *invec_int = (int *)invec; int *inoutvec_int = (int *)inoutvec; if (*datatype != MPI_INT) { ++uop_errs; printf("invalid datatype passed to user_op"); return; } for (i = 0; i < *len; ++i) { inoutvec_int[i] = invec_int[i] * 2 + inoutvec_int[i]; } } int main( int argc, char *argv[] ) { int errs = 0; #if MTEST_HAVE_MIN_MPI_VERSION(2,2) int i; int *inbuf = NULL; int *inoutbuf = NULL; int count = -1; MPI_Op uop = MPI_OP_NULL; #endif MTest_Init(&argc, &argv); #if MTEST_HAVE_MIN_MPI_VERSION(2,2) /* this function was added in MPI-2.2 */ inbuf = malloc(sizeof(int) * MAX_BUF_ELEMENTS); inoutbuf = malloc(sizeof(int) * MAX_BUF_ELEMENTS); for (count = 0; count < MAX_BUF_ELEMENTS; count > 0 ? count*=2 : count++) { for (i = 0; i < count; ++i) { inbuf[i] = i; inoutbuf[i] = i; } MPI_Reduce_local(inbuf, inoutbuf, count, MPI_INT, MPI_SUM); for (i = 0; i < count; ++i) if (inbuf[i] != i) { ++errs; if (inoutbuf[i] != (2*i)) ++errs; } } /* make sure that user-define ops work too */ MPI_Op_create(&user_op, 0/*!commute*/, &uop); for (count = 0; count < MAX_BUF_ELEMENTS; count > 0 ? count*=2 : count++) { for (i = 0; i < count; ++i) { inbuf[i] = i; inoutbuf[i] = i; } MPI_Reduce_local(inbuf, inoutbuf, count, MPI_INT, uop); errs += uop_errs; for (i = 0; i < count; ++i) if (inbuf[i] != i) { ++errs; if (inoutbuf[i] != (3*i)) ++errs; } } MPI_Op_free(&uop); free(inbuf); free(inoutbuf); #endif MTest_Finalize(errs); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/allredmany.c000644 001750 001750 00000001414 12342443661 022403 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include "mpi.h" /* * This example should be run with 2 processes and tests the ability of the * implementation to handle a flood of one-way messages. */ int main( int argc, char **argv ) { double wscale = 10.0, scale; int numprocs, myid,i; MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD,&numprocs); MPI_Comm_rank(MPI_COMM_WORLD,&myid); for ( i=0; i<10000; i++) { MPI_Allreduce(&wscale,&scale,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); } if (myid == 0) { /* If we get here at all, we're ok */ printf( " No Errors\n" ); } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/gather.c000644 001750 001750 00000003267 12342443661 021535 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitest.h" #include #include /* Gather data from a vector to contiguous */ int main( int argc, char **argv ) { MPI_Datatype vec; MPI_Comm comm; double *vecin, *vecout; int minsize = 2, count; int root, i, n, stride, errs = 0; int rank, size; MTest_Init( &argc, &argv ); while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); for (root=0; root #include #include "mpitest.h" int main( int argc, char **argv ) { int err = 0; int *recvcounts; int size, rsize, rank, i; int recvcount, /* Each process receives this much data */ sendcount, /* Each process contributes this much data */ basecount; /* Unit of elements - basecount *rsize is recvcount, etc. */ int isLeftGroup; long long *sendbuf, *recvbuf; long long sumval; MPI_Comm comm; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; basecount = 1024; while (MTestGetIntercomm( &comm, &isLeftGroup, 2 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_remote_size( comm, &rsize ); MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); if (0) { printf( "[%d] %s (%d,%d) remote %d\n", rank, isLeftGroup ? "L" : "R", rank, size, rsize ); } recvcount = basecount * rsize; sendcount = basecount * rsize * size; recvcounts = (int *)malloc( size * sizeof(int) ); if (!recvcounts) { fprintf( stderr, "Could not allocate %d int for recvcounts\n", size ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } for (i=0; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple intercomm gatherv test"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int *buf = 0; int *recvcounts; int *recvdispls; int leftGroup, i, count, rank, rsize, size; MPI_Comm comm; MPI_Datatype datatype; MTest_Init( &argc, &argv ); datatype = MPI_INT; while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_rank( comm, &rank ); MPI_Comm_remote_size( comm, &rsize ); MPI_Comm_size( comm, &size ); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN ); for (count = 1; count < 65000; count = 2 * count) { /* Get an intercommunicator */ recvcounts = (int *)malloc( rsize * sizeof(int) ); recvdispls = (int *)malloc( rsize * sizeof(int) ); /* This simple test duplicates the Gather test, using the same lengths for all messages */ for (i=0; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple intercomm reduce test"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int *sendbuf = 0, *recvbuf=0; int leftGroup, i, count, rank, rsize; MPI_Comm comm; MPI_Datatype datatype; MTest_Init( &argc, &argv ); datatype = MPI_INT; /* Get an intercommunicator */ while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_rank( comm, &rank ); MPI_Comm_remote_size( comm, &rsize ); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN ); for (count = 1; count < 65000; count = 2 * count) { sendbuf = (int *)malloc( count * sizeof(int) ); recvbuf = (int *)malloc( count * sizeof(int) ); for (i=0; i #include int main(int argc, char **argv) { int err = 0; int toterr, size, rank; #if MTEST_HAVE_MIN_MPI_VERSION(2,2) int i, sumval; int *sendbuf; int *recvbuf; #endif MPI_Comm comm; MPI_Init(&argc, &argv); comm = MPI_COMM_WORLD; MPI_Comm_size(comm, &size); MPI_Comm_rank(comm, &rank); #if MTEST_HAVE_MIN_MPI_VERSION(2,2) /* MPI_Reduce_scatter block was added in MPI-2.2 */ sendbuf = (int *) malloc(size * sizeof(int)); recvbuf = (int *) malloc(size * sizeof(int)); if (!sendbuf || !recvbuf) { err++; fprintf(stderr, "unable to allocate send/recv buffers, aborting"); MPI_Abort(MPI_COMM_WORLD, 1); exit(1); } for (i=0; i #include #include "mpitest.h" #include #include #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #define EXIT_FAILURE 1 #endif int main( int argc, char *argv[] ) { int rank, size; int chunk = 128; int i; int *sb; int *rb; int status; MTest_Init(&argc,&argv); MPI_Comm_rank(MPI_COMM_WORLD,&rank); MPI_Comm_size(MPI_COMM_WORLD,&size); for ( i=1 ; i < argc ; ++i ) { if ( argv[i][0] != '-' ) continue; switch(argv[i][1]) { case 'm': chunk = atoi(argv[++i]); break; default: fprintf(stderr,"Unrecognized argument %s\n", argv[i]); MPI_Abort(MPI_COMM_WORLD,EXIT_FAILURE); exit(EXIT_FAILURE); } } sb = (int *)malloc(size*chunk*sizeof(int)); if ( !sb ) { perror( "can't allocate send buffer" ); MPI_Abort(MPI_COMM_WORLD,EXIT_FAILURE); exit(EXIT_FAILURE); } rb = (int *)malloc(size*chunk*sizeof(int)); if ( !rb ) { perror( "can't allocate recv buffer"); free(sb); MPI_Abort(MPI_COMM_WORLD,EXIT_FAILURE); exit(EXIT_FAILURE); } for ( i=0 ; i < size*chunk ; ++i ) { sb[i] = rank + 1; rb[i] = 0; } /* fputs("Before MPI_Alltoall\n",stdout); */ /* This should really send MPI_CHAR, but since sb and rb were allocated as chunk*size*sizeof(int), the buffers are large enough */ status = MPI_Alltoall(sb,chunk,MPI_INT,rb,chunk,MPI_INT, MPI_COMM_WORLD); /* fputs("Before MPI_Allreduce\n",stdout); */ MTest_Finalize( status ); free(sb); free(rb); MPI_Finalize(); return MTestReturnValue( status ); } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/coll8.c000644 001750 001750 00000002341 12342443661 021274 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" int main( int argc, char **argv ) { int rank, size, i; int data; int errors=0; int result = -100; int correct_result; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); data = rank; MPI_Reduce ( &data, &result, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD ); MPI_Bcast ( &result, 1, MPI_INT, 0, MPI_COMM_WORLD ); correct_result = 0; for(i=0;i #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_LOR operations on optional datatypes dupported by MPICH"; */ /* * This test looks at the handling of logical and for types that are not * integers or are not required integers (e.g., long long). MPICH allows * these as well. A strict MPI test should not include this test. */ int main( int argc, char *argv[] ) { int errs = 0, err; int rank, size; MPI_Comm comm; char cinbuf[3], coutbuf[3]; signed char scinbuf[3], scoutbuf[3]; unsigned char ucinbuf[3], ucoutbuf[3]; float finbuf[3], foutbuf[3]; double dinbuf[3], doutbuf[3]; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); /* Some MPI implementations do not implement all of the required (datatype,operations) combinations, and further, they do not always provide clear and specific error messages. By catching the error, we can provide a higher quality, more specific message. */ MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN ); #ifndef USE_STRICT_MPI /* char */ MTestPrintfMsg( 10, "Reduce of MPI_CHAR\n" ); cinbuf[0] = 1; cinbuf[1] = 0; cinbuf[2] = (rank > 0); coutbuf[0] = 0; coutbuf[1] = 1; coutbuf[2] = 1; err = MPI_Reduce( cinbuf, coutbuf, 3, MPI_CHAR, MPI_LOR, 0, comm ); if (err) { errs++; MTestPrintErrorMsg( "MPI_LOR and MPI_CHAR", err ); } else { if (rank == 0) { if (!coutbuf[0]) { errs++; fprintf( stderr, "char OR(1) test failed\n" ); } if (coutbuf[1]) { errs++; fprintf( stderr, "char OR(0) test failed\n" ); } if (!coutbuf[2] && size > 1) { errs++; fprintf( stderr, "char OR(>) test failed\n" ); } } } #endif /* USE_STRICT_MPI */ /* signed char */ MTestPrintfMsg( 10, "Reduce of MPI_SIGNED_CHAR\n" ); scinbuf[0] = 1; scinbuf[1] = 0; scinbuf[2] = (rank > 0); scoutbuf[0] = 0; scoutbuf[1] = 1; scoutbuf[2] = 1; err = MPI_Reduce( scinbuf, scoutbuf, 3, MPI_SIGNED_CHAR, MPI_LOR, 0, comm ); if (err) { errs++; MTestPrintErrorMsg( "MPI_LOR and MPI_SIGNED_CHAR", err ); } else { if (rank == 0) { if (!scoutbuf[0]) { errs++; fprintf( stderr, "signed char OR(1) test failed\n" ); } if (scoutbuf[1]) { errs++; fprintf( stderr, "signed char OR(0) test failed\n" ); } if (!scoutbuf[2] && size > 1) { errs++; fprintf( stderr, "signed char OR(>) test failed\n" ); } } } /* unsigned char */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_CHAR\n" ); ucinbuf[0] = 1; ucinbuf[1] = 0; ucinbuf[2] = (rank > 0); ucoutbuf[0] = 0; ucoutbuf[1] = 1; ucoutbuf[2] = 1; err = MPI_Reduce( ucinbuf, ucoutbuf, 3, MPI_UNSIGNED_CHAR, MPI_LOR, 0, comm ); if (err) { errs++; MTestPrintErrorMsg( "MPI_LOR and MPI_UNSIGNED_CHAR", err ); } else { if (rank == 0) { if (!ucoutbuf[0]) { errs++; fprintf( stderr, "unsigned char OR(1) test failed\n" ); } if (ucoutbuf[1]) { errs++; fprintf( stderr, "unsigned char OR(0) test failed\n" ); } if (!ucoutbuf[2] && size > 1) { errs++; fprintf( stderr, "unsigned char OR(>) test failed\n" ); } } } #ifndef USE_STRICT_MPI /* float */ MTestPrintfMsg( 10, "Reduce of MPI_FLOAT\n" ); finbuf[0] = 1; finbuf[1] = 0; finbuf[2] = (rank > 0); foutbuf[0] = 0; foutbuf[1] = 1; foutbuf[2] = 1; err = MPI_Reduce( finbuf, foutbuf, 3, MPI_FLOAT, MPI_LOR, 0, comm ); if (err) { errs++; MTestPrintErrorMsg( "MPI_LOR and MPI_FLOAT", err ); } else { if (rank == 0) { if (!foutbuf[0]) { errs++; fprintf( stderr, "float OR(1) test failed\n" ); } if (foutbuf[1]) { errs++; fprintf( stderr, "float OR(0) test failed\n" ); } if (!foutbuf[2] && size > 1) { errs++; fprintf( stderr, "float OR(>) test failed\n" ); } } } /* double */ MTestPrintfMsg( 10, "Reduce of MPI_DOUBLE\n" ); dinbuf[0] = 1; dinbuf[1] = 0; dinbuf[2] = (rank > 0); doutbuf[0] = 0; doutbuf[1] = 1; doutbuf[2] = 1; err = MPI_Reduce( dinbuf, doutbuf, 3, MPI_DOUBLE, MPI_LOR, 0, comm ); if (err) { errs++; MTestPrintErrorMsg( "MPI_LOR and MPI_DOUBLE", err ); } else { if (rank == 0) { if (!doutbuf[0]) { errs++; fprintf( stderr, "double OR(1) test failed\n" ); } if (doutbuf[1]) { errs++; fprintf( stderr, "double OR(0) test failed\n" ); } if (!doutbuf[2] && size > 1) { errs++; fprintf( stderr, "double OR(>) test failed\n" ); } } } #ifdef HAVE_LONG_DOUBLE { long double ldinbuf[3], ldoutbuf[3]; /* long double */ ldinbuf[0] = 1; ldinbuf[1] = 0; ldinbuf[2] = (rank > 0); ldoutbuf[0] = 0; ldoutbuf[1] = 1; ldoutbuf[2] = 1; if (MPI_LONG_DOUBLE != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_DOUBLE\n" ); err = MPI_Reduce( ldinbuf, ldoutbuf, 3, MPI_LONG_DOUBLE, MPI_LOR, 0, comm ); if (err) { errs++; MTestPrintErrorMsg( "MPI_LOR and MPI_LONG_DOUBLE", err ); } else { if (rank == 0) { if (!ldoutbuf[0]) { errs++; fprintf( stderr, "long double OR(1) test failed\n" ); } if (ldoutbuf[1]) { errs++; fprintf( stderr, "long double OR(0) test failed\n" ); } if (!ldoutbuf[2] && size > 1) { errs++; fprintf( stderr, "long double OR(>) test failed\n" ); } } } } } #endif /* HAVE_LONG_DOUBLE */ #endif /* USE_STRICT_MPI */ #ifdef HAVE_LONG_LONG { long long llinbuf[3], lloutbuf[3]; /* long long */ llinbuf[0] = 1; llinbuf[1] = 0; llinbuf[2] = (rank > 0); lloutbuf[0] = 0; lloutbuf[1] = 1; lloutbuf[2] = 1; if (MPI_LONG_LONG != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_LONG\n" ); err = MPI_Reduce( llinbuf, lloutbuf, 3, MPI_LONG_LONG, MPI_LOR, 0, comm ); if (err) { errs++; MTestPrintErrorMsg( "MPI_LOR and MPI_LONG_LONG", err ); } else { if (rank == 0) { if (!lloutbuf[0]) { errs++; fprintf( stderr, "long long OR(1) test failed\n" ); } if (lloutbuf[1]) { errs++; fprintf( stderr, "long long OR(0) test failed\n" ); } if (!lloutbuf[2] && size > 1) { errs++; fprintf( stderr, "long long OR(>) test failed\n" ); } } } } } #endif MPI_Errhandler_set( comm, MPI_ERRORS_ARE_FATAL ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/alltoallw_zeros.c000644 001750 001750 00000006611 12342443661 023474 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2009 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* Based on a test case contributed by Michael Hofmann. * * This test makes sure that zero counts with non-zero-sized types on the * send (recv) side match and don't cause a problem with non-zero counts and * zero-sized types on the recv (send) side when using MPI_Alltoallw and * MPI_Alltoallv. */ /* TODO test intercommunicators as well */ #include #include #include #include "mpitest.h" int main(int argc, char *argv[]) { int sendbuf, recvbuf; int *sendcounts; int *recvcounts; int *sdispls; int *rdispls; MPI_Datatype sendtype; MPI_Datatype *sendtypes; MPI_Datatype *recvtypes; int rank = -1; int size = -1; int i; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); sendtypes = malloc(size * sizeof(MPI_Datatype)); recvtypes = malloc(size * sizeof(MPI_Datatype)); sendcounts = malloc(size * sizeof(int)); recvcounts = malloc(size * sizeof(int)); sdispls = malloc(size * sizeof(int)); rdispls = malloc(size * sizeof(int)); if (!sendtypes || !recvtypes || !sendcounts || !recvcounts || !sdispls || !rdispls) { printf("error, unable to allocate memory\n"); goto fn_exit; } MPI_Type_contiguous(0, MPI_INT, &sendtype); MPI_Type_commit(&sendtype); for (i = 0; i < size; ++i) { sendtypes[i] = sendtype; sendcounts[i] = 1; sdispls[i] = 0; recvtypes[i] = MPI_INT; recvcounts[i] = 0; rdispls[i] = 0; } /* try zero-counts on both the send and recv side in case only one direction is broken for some reason */ MPI_Alltoallw(&sendbuf, sendcounts, sdispls, sendtypes, &recvbuf, recvcounts, rdispls, recvtypes, MPI_COMM_WORLD); MPI_Alltoallw(&sendbuf, recvcounts, rdispls, recvtypes, &recvbuf, sendcounts, sdispls, sendtypes, MPI_COMM_WORLD); #if MTEST_HAVE_MIN_MPI_VERSION(2,2) /* pass MPI_IN_PLACE and different but compatible types rank is even/odd */ if (rank % 2) MPI_Alltoallw(MPI_IN_PLACE, NULL, NULL, NULL, &recvbuf, recvcounts, rdispls, recvtypes, MPI_COMM_WORLD); else MPI_Alltoallw(MPI_IN_PLACE, NULL, NULL, NULL, &recvbuf, sendcounts, sdispls, sendtypes, MPI_COMM_WORLD); #endif /* now the same for Alltoallv instead of Alltoallw */ MPI_Alltoallv(&sendbuf, sendcounts, sdispls, sendtypes[0], &recvbuf, recvcounts, rdispls, recvtypes[0], MPI_COMM_WORLD); MPI_Alltoallv(&sendbuf, recvcounts, rdispls, recvtypes[0], &recvbuf, sendcounts, sdispls, sendtypes[0], MPI_COMM_WORLD); #if MTEST_HAVE_MIN_MPI_VERSION(2,2) if (rank % 2) MPI_Alltoallv(MPI_IN_PLACE, NULL, NULL, MPI_DATATYPE_NULL, &recvbuf, recvcounts, rdispls, recvtypes[0], MPI_COMM_WORLD); else MPI_Alltoallv(MPI_IN_PLACE, NULL, NULL, MPI_DATATYPE_NULL, &recvbuf, sendcounts, sdispls, sendtypes[0], MPI_COMM_WORLD); #endif MPI_Type_free(&sendtype); if (rank == 0) printf(" No Errors\n"); fn_exit: if (rdispls) free(rdispls); if (sdispls) free(sdispls); if (recvcounts) free(recvcounts); if (sendcounts) free(sendcounts); if (recvtypes) free(recvtypes); if (sendtypes) free(sendtypes); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/coll4.c000644 001750 001750 00000003143 12342443661 021271 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" #define MAX_PROCESSES 10 int main( int argc, char **argv ) { int rank, size, i,j; int table[MAX_PROCESSES][MAX_PROCESSES]; int row[MAX_PROCESSES]; int errors=0; int participants; MPI_Comm comm; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); comm = MPI_COMM_WORLD; /* A maximum of MAX_PROCESSES processes can participate */ if ( size > MAX_PROCESSES ) { participants = MAX_PROCESSES; MPI_Comm_split( MPI_COMM_WORLD, rank < MAX_PROCESSES, rank, &comm ); } else { participants = size; MPI_Comm_dup( MPI_COMM_WORLD, &comm ); } if ( (rank < participants) ) { int send_count = MAX_PROCESSES; int recv_count = MAX_PROCESSES; /* If I'm the root (process 0), then fill out the big table */ if (rank == 0) for ( i=0; i #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_BXOR operations on optional datatypes dupported by MPICH"; */ /* * This test looks at the handling of logical and for types that are not * integers or are not required integers (e.g., long long). MPICH allows * these as well. A strict MPI test should not include this test. */ int main( int argc, char *argv[] ) { int errs = 0; int rc; int rank, size; MPI_Comm comm; char cinbuf[3], coutbuf[3]; signed char scinbuf[3], scoutbuf[3]; unsigned char ucinbuf[3], ucoutbuf[3]; short sinbuf[3], soutbuf[3]; unsigned short usinbuf[3], usoutbuf[3]; long linbuf[3], loutbuf[3]; unsigned long ulinbuf[3], uloutbuf[3]; unsigned uinbuf[3], uoutbuf[3]; int iinbuf[3], ioutbuf[3]; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; /* Set errors return so that we can provide better information should a routine reject one of the operand/datatype pairs */ MPI_Errhandler_set( comm, MPI_ERRORS_RETURN ); MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); #ifndef USE_STRICT_MPI /* char */ MTestPrintfMsg( 10, "Reduce of MPI_CHAR\n" ); cinbuf[0] = 0xff; cinbuf[1] = 0; cinbuf[2] = (rank > 0) ? 0x3c : 0xc3; coutbuf[0] = 0xf; coutbuf[1] = 1; coutbuf[2] = 1; rc = MPI_Reduce( cinbuf, coutbuf, 3, MPI_CHAR, MPI_BXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BXOR and MPI_CHAR", rc ); errs++; } else { if (rank == 0) { if (coutbuf[0] != ((size % 2) ? (char)0xff : (char)0) ) { errs++; fprintf( stderr, "char BXOR(1) test failed\n" ); } if (coutbuf[1]) { errs++; fprintf( stderr, "char BXOR(0) test failed\n" ); } if (coutbuf[2] != ((size % 2) ? (char)0xc3 : (char)0xff)) { errs++; fprintf( stderr, "char BXOR(>) test failed\n" ); } } } #endif /* USE_STRICT_MPI */ /* signed char */ MTestPrintfMsg( 10, "Reduce of MPI_SIGNED_CHAR\n" ); scinbuf[0] = 0xff; scinbuf[1] = 0; scinbuf[2] = (rank > 0) ? 0x3c : 0xc3; scoutbuf[0] = 0xf; scoutbuf[1] = 1; scoutbuf[2] = 1; rc = MPI_Reduce( scinbuf, scoutbuf, 3, MPI_SIGNED_CHAR, MPI_BXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BXOR and MPI_SIGNED_CHAR", rc ); errs++; } else { if (rank == 0) { if (scoutbuf[0] != ((size % 2) ? (signed char)0xff : (signed char)0) ) { errs++; fprintf( stderr, "signed char BXOR(1) test failed\n" ); } if (scoutbuf[1]) { errs++; fprintf( stderr, "signed char BXOR(0) test failed\n" ); } if (scoutbuf[2] != ((size % 2) ? (signed char)0xc3 : (signed char)0xff)) { errs++; fprintf( stderr, "signed char BXOR(>) test failed\n" ); } } } /* unsigned char */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_CHAR\n" ); ucinbuf[0] = 0xff; ucinbuf[1] = 0; ucinbuf[2] = (rank > 0) ? 0x3c : 0xc3; ucoutbuf[0] = 0; ucoutbuf[1] = 1; ucoutbuf[2] = 1; rc = MPI_Reduce( ucinbuf, ucoutbuf, 3, MPI_UNSIGNED_CHAR, MPI_BXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BXOR and MPI_UNSIGNED_CHAR", rc ); errs++; } else { if (rank == 0) { if (ucoutbuf[0] != ((size % 2) ? 0xff : 0)) { errs++; fprintf( stderr, "unsigned char BXOR(1) test failed\n" ); } if (ucoutbuf[1]) { errs++; fprintf( stderr, "unsigned char BXOR(0) test failed\n" ); } if (ucoutbuf[2] != ((size % 2) ? (unsigned char)0xc3 : (unsigned char)0xff)) { errs++; fprintf( stderr, "unsigned char BXOR(>) test failed\n" ); } } } /* bytes */ MTestPrintfMsg( 10, "Reduce of MPI_BYTE\n" ); cinbuf[0] = 0xff; cinbuf[1] = 0; cinbuf[2] = (rank > 0) ? 0x3c : 0xc3; coutbuf[0] = 0; coutbuf[1] = 1; coutbuf[2] = 1; rc = MPI_Reduce( cinbuf, coutbuf, 3, MPI_BYTE, MPI_BXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BXOR and MPI_BYTE", rc ); errs++; } else { if (rank == 0) { if (coutbuf[0] != ((size % 2) ? (char)0xff : 0)) { errs++; fprintf( stderr, "byte BXOR(1) test failed\n" ); } if (coutbuf[1]) { errs++; fprintf( stderr, "byte BXOR(0) test failed\n" ); } if (coutbuf[2] != ((size % 2) ? (char)0xc3 : (char)0xff)) { errs++; fprintf( stderr, "byte BXOR(>) test failed\n" ); } } } /* short */ MTestPrintfMsg( 10, "Reduce of MPI_SHORT\n" ); sinbuf[0] = 0xffff; sinbuf[1] = 0; sinbuf[2] = (rank > 0) ? 0x3c3c : 0xc3c3; soutbuf[0] = 0; soutbuf[1] = 1; soutbuf[2] = 1; rc = MPI_Reduce( sinbuf, soutbuf, 3, MPI_SHORT, MPI_BXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BXOR and MPI_SHORT", rc ); errs++; } else { if (rank == 0) { if (soutbuf[0] != ((size % 2) ? (short)0xffff : 0)) { errs++; fprintf( stderr, "short BXOR(1) test failed\n" ); } if (soutbuf[1]) { errs++; fprintf( stderr, "short BXOR(0) test failed\n" ); } if (soutbuf[2] != ((size % 2) ? (short)0xc3c3 : (short)0xffff)) { errs++; fprintf( stderr, "short BXOR(>) test failed\n" ); } } } /* unsigned short */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_SHORT\n" ); usinbuf[0] = 0xffff; usinbuf[1] = 0; usinbuf[2] = (rank > 0) ? 0x3c3c : 0xc3c3; usoutbuf[0] = 0; usoutbuf[1] = 1; usoutbuf[2] = 1; rc = MPI_Reduce( usinbuf, usoutbuf, 3, MPI_UNSIGNED_SHORT, MPI_BXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BXOR and MPI_UNSIGNED_SHORT", rc ); errs++; } else { if (rank == 0) { if (usoutbuf[0] != ((size % 2) ? 0xffff : 0)) { errs++; fprintf( stderr, "short BXOR(1) test failed\n" ); } if (usoutbuf[1]) { errs++; fprintf( stderr, "short BXOR(0) test failed\n" ); } if (usoutbuf[2] != ((size % 2) ? 0xc3c3 : 0xffff)) { errs++; fprintf( stderr, "short BXOR(>) test failed\n" ); } } } /* unsigned */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED\n" ); uinbuf[0] = 0xffffffff; uinbuf[1] = 0; uinbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3; uoutbuf[0] = 0; uoutbuf[1] = 1; uoutbuf[2] = 1; rc = MPI_Reduce( uinbuf, uoutbuf, 3, MPI_UNSIGNED, MPI_BXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BXOR and MPI_UNSIGNED", rc ); errs++; } else { if (rank == 0) { if (uoutbuf[0] != ((size % 2) ? 0xffffffff : 0)) { errs++; fprintf( stderr, "unsigned BXOR(1) test failed\n" ); } if (uoutbuf[1]) { errs++; fprintf( stderr, "unsigned BXOR(0) test failed\n" ); } if (uoutbuf[2] != ((size % 2) ? 0xc3c3c3c3 : 0xffffffff)) { errs++; fprintf( stderr, "unsigned BXOR(>) test failed\n" ); } } } /* int */ MTestPrintfMsg( 10, "Reduce of MPI_INT\n" ); iinbuf[0] = 0xffffffff; iinbuf[1] = 0; iinbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3; ioutbuf[0] = 0; ioutbuf[1] = 1; ioutbuf[2] = 1; rc = MPI_Reduce( iinbuf, ioutbuf, 3, MPI_INT, MPI_BXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BXOR and MPI_INT", rc ); errs++; } else { if (rank == 0) { if (ioutbuf[0] != ((size % 2) ? 0xffffffff : 0)) { errs++; fprintf( stderr, "int BXOR(1) test failed\n" ); } if (ioutbuf[1]) { errs++; fprintf( stderr, "int BXOR(0) test failed\n" ); } if (ioutbuf[2] != ((size % 2) ? 0xc3c3c3c3 : 0xffffffff)) { errs++; fprintf( stderr, "int BXOR(>) test failed\n" ); } } } /* long */ MTestPrintfMsg( 10, "Reduce of MPI_LONG\n" ); linbuf[0] = 0xffffffff; linbuf[1] = 0; linbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3; loutbuf[0] = 0; loutbuf[1] = 1; loutbuf[2] = 1; rc = MPI_Reduce( linbuf, loutbuf, 3, MPI_LONG, MPI_BXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BXOR and MPI_LONG", rc ); errs++; } else { if (rank == 0) { if (loutbuf[0] != ((size % 2) ? 0xffffffff : 0)) { errs++; fprintf( stderr, "long BXOR(1) test failed\n" ); } if (loutbuf[1]) { errs++; fprintf( stderr, "long BXOR(0) test failed\n" ); } if (loutbuf[2] != ((size % 2) ? 0xc3c3c3c3 : 0xffffffff)) { errs++; fprintf( stderr, "long BXOR(>) test failed\n" ); } } } /* unsigned long */ MTestPrintfMsg( 10, "Reduce of MPI_UNSIGNED_LONG\n" ); ulinbuf[0] = 0xffffffff; ulinbuf[1] = 0; ulinbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3; uloutbuf[0] = 0; uloutbuf[1] = 1; uloutbuf[2] = 1; rc = MPI_Reduce( ulinbuf, uloutbuf, 3, MPI_UNSIGNED_LONG, MPI_BXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BXOR and MPI_UNSIGNED_LONG", rc ); errs++; } else { if (rank == 0) { if (uloutbuf[0] != ((size % 2) ? 0xffffffff : 0)) { errs++; fprintf( stderr, "unsigned long BXOR(1) test failed\n" ); } if (uloutbuf[1]) { errs++; fprintf( stderr, "unsigned long BXOR(0) test failed\n" ); } if (uloutbuf[2] != ((size % 2) ? 0xc3c3c3c3 : 0xffffffff)) { errs++; fprintf( stderr, "unsigned long BXOR(>) test failed\n" ); } } } #ifdef HAVE_LONG_LONG { long long llinbuf[3], lloutbuf[3]; /* long long */ llinbuf[0] = 0xffffffff; llinbuf[1] = 0; llinbuf[2] = (rank > 0) ? 0x3c3c3c3c : 0xc3c3c3c3; lloutbuf[0] = 0; lloutbuf[1] = 1; lloutbuf[2] = 1; if (MPI_LONG_LONG != MPI_DATATYPE_NULL) { MTestPrintfMsg( 10, "Reduce of MPI_LONG_LONG\n" ); rc = MPI_Reduce( llinbuf, lloutbuf, 3, MPI_LONG_LONG, MPI_BXOR, 0, comm ); if (rc) { MTestPrintErrorMsg( "MPI_BXOR and MPI_LONG_LONG", rc ); errs++; } else { if (rank == 0) { if (lloutbuf[0] != ((size % 2) ? 0xffffffff : 0)) { errs++; fprintf( stderr, "long long BXOR(1) test failed\n" ); } if (lloutbuf[1]) { errs++; fprintf( stderr, "long long BXOR(0) test failed\n" ); } if (lloutbuf[2] != ((size % 2) ? 0xc3c3c3c3 : 0xffffffff)) { errs++; fprintf( stderr, "long long BXOR(>) test failed\n" ); } } } } } #endif MPI_Errhandler_set( comm, MPI_ERRORS_ARE_FATAL ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/coll/redscat3.c000644 001750 001750 00000005504 12342443661 021767 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2010 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* * Test of reduce scatter with large data (needed in MPICH to trigger the * long-data algorithm) * * Each processor contributes its rank + the index to the reduction, * then receives the ith sum * * Can be called with any number of processors. */ #include "mpi.h" #include #include #include "mpitest.h" /* Limit the number of error reports */ #define MAX_ERRORS 10 int main( int argc, char **argv ) { int err = 0; int *sendbuf, *recvbuf, *recvcounts; int size, rank, i, j, idx, mycount, sumval; MPI_Comm comm; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); recvcounts = (int *)malloc( size * sizeof(int) ); if (!recvcounts) { fprintf( stderr, "Could not allocate %d ints for recvcounts\n", size ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } mycount = (1024 * 1024) / size; for (i=0; i #include #include "mpitest.h" int err = 0; /* left(x,y) ==> x */ void left(void *a, void *b, int *count, MPI_Datatype *type); void left(void *a, void *b, int *count, MPI_Datatype *type) { int *in = a; int *inout = b; int i; for (i = 0; i < *count; ++i) { if (in[i] > inout[i]) ++err; inout[i] = in[i]; } } /* right(x,y) ==> y */ void right(void *a, void *b, int *count, MPI_Datatype *type); void right(void *a, void *b, int *count, MPI_Datatype *type) { int *in = a; int *inout = b; int i; for (i = 0; i < *count; ++i) { if (in[i] > inout[i]) ++err; inout[i] = inout[i]; } } /* Just performs a simple sum but can be marked as non-commutative to potentially tigger different logic in the implementation. */ void nc_sum(void *a, void *b, int *count, MPI_Datatype *type); void nc_sum(void *a, void *b, int *count, MPI_Datatype *type) { int *in = a; int *inout = b; int i; for (i = 0; i < *count; ++i) { inout[i] = in[i] + inout[i]; } } #define MAX_BLOCK_SIZE 256 int main( int argc, char **argv ) { #if MTEST_HAVE_MIN_MPI_VERSION(2,2) int *sendbuf; int block_size; int *recvbuf; int i; MPI_Op left_op, right_op, nc_sum_op; #endif int size, rank; MPI_Comm comm; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); #if MTEST_HAVE_MIN_MPI_VERSION(2,2) /* MPI_Reduce_scatter block was added in MPI-2.2 */ MPI_Op_create(&left, 0/*non-commutative*/, &left_op); MPI_Op_create(&right, 0/*non-commutative*/, &right_op); MPI_Op_create(&nc_sum, 0/*non-commutative*/, &nc_sum_op); for (block_size = 1; block_size < MAX_BLOCK_SIZE; block_size *= 2) { sendbuf = (int *) malloc( block_size * size * sizeof(int) ); recvbuf = malloc( block_size * sizeof(int) ); for (i=0; i<(size*block_size); i++) sendbuf[i] = rank + i; for (i=0; i #include "mpitest.h" /* static char MTEST_Descrip[] = "Test of broadcast with various roots and datatypes and sizes that are not powers of two"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int rank, size, root; int minsize = 2, count; MPI_Comm comm; MTestDatatype sendtype, recvtype; MTest_Init( &argc, &argv ); /* The following illustrates the use of the routines to run through a selection of communicators and datatypes. Use subsets of these for tests that do not involve combinations of communicators, datatypes, and counts of datatypes */ while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); count = 1; /* This must be very large to ensure that we reach the long message algorithms */ for (count = 4; count < 66000; count = count * 4) { while (MTestGetDatatypes( &sendtype, &recvtype, count-1 )) { for (root=0; root #include /* * Test user-defined operations with a large number of elements. * Added because a talk at EuroMPI'12 claimed that these failed with * more than 64k elements */ #define MAX_ERRS 10 #define MAX_COUNT 1200000 void myop( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype ); /* * myop takes a datatype that is a triple of doubles, and computes * the sum, max, min of the respective elements of the triple. */ void myop( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype ) { int i, n = *count; double const *cin = (double *)cinPtr; double *cout = (double *)coutPtr; for (i=0; i cin[1]) ? cout[1] : cin[1]; cout[2] = (cout[2] < cin[2]) ? cout[2] : cin[2]; cin += 3; cout += 3; } } int main( int argc, char *argv[] ) { int errs = 0; int wsize, wrank, i, count; MPI_Datatype tripleType; double *inVal, *outVal; double maxval, sumval; MPI_Op op; MTest_Init( &argc, &argv ); MPI_Op_create( myop, 0, &op ); MPI_Type_contiguous( 3, MPI_DOUBLE, &tripleType ); MPI_Type_commit( &tripleType ); MPI_Comm_size( MPI_COMM_WORLD, &wsize ); MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); for (count=1; count #include /* Gather data from a vector to contiguous. Use IN_PLACE. This is the trivial version based on the allgather test (allgatherv but with constant data sizes) */ int main( int argc, char **argv ) { double *vecout; MPI_Comm comm; int count, minsize = 2; int i, errs = 0; int rank, size; int *displs, *recvcounts; MTest_Init( &argc, &argv ); while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); displs = (int *)malloc( size * sizeof(int) ); recvcounts = (int *)malloc( size * sizeof(int) ); for (count = 1; count < 9000; count = count * 2) { vecout = (double *)malloc( size * count * sizeof(double) ); for (i=0; i #include int add ( double *, double *, int *, MPI_Datatype * ); /* * User-defined operation on a long value (tests proper handling of * possible pipelining in the implementation of reductions with user-defined * operations). */ int add( double *invec, double *inoutvec, int *len, MPI_Datatype *dtype ) { int i, n = *len; for (i=0; i #include #include "mpitest.h" int main( int argc, char **argv ) { int err = 0; int *sendbuf, *recvbuf; int size, rank, i, j, idx, mycount, sumval; MPI_Comm comm; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); mycount = (1024 * 1024) / size; sendbuf = (int *) malloc( mycount * size * sizeof(int) ); if (!sendbuf) { fprintf( stderr, "Could not allocate %d ints for sendbuf\n", mycount * size ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } idx = 0; for (i=0; i #include "mpi.h" #include "../../include/mpitestconf.h" #include /* Name mapping. All routines are created with names that are lower case with a single trailing underscore. This matches many compilers. We use #define to change the name for Fortran compilers that do not use the lowercase/underscore pattern */ #ifdef F77_NAME_UPPER #define c2fcomm_ C2FCOMM #define c2fgroup_ C2FGROUP #define c2ftype_ C2FTYPE #define c2finfo_ C2FINFO #define c2frequest_ C2FREQUEST #define c2fop_ C2FOP #define c2ferrhandler_ C2FERRHANDLER #define f2ccomm_ F2CCOMM #define f2cgroup_ F2CGROUP #define f2ctype_ F2CTYPE #define f2cinfo_ F2CINFO #define f2crequest_ F2CREQUEST #define f2cop_ F2COP #define f2cerrhandler_ F2CERRHANDLER #elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED) /* Mixed is ok because we use lowercase in all uses */ #define c2fcomm_ c2fcomm #define c2fgroup_ c2fgroup #define c2ftype_ c2ftype #define c2finfo_ c2finfo #define c2frequest_ c2frequest #define c2fop_ c2fop #define c2ferrhandler_ c2ferrhandler #define f2ccomm_ f2ccomm #define f2cgroup_ f2cgroup #define f2ctype_ f2ctype #define f2cinfo_ f2cinfo #define f2crequest_ f2crequest #define f2cop_ f2cop #define f2cerrhandler_ f2cerrhandler #elif defined(F77_NAME_LOWER_2USCORE) || defined(F77_NAME_LOWER_USCORE) || \ defined(F77_NAME_MIXED_USCORE) /* Else leave name alone (routines have no underscore, so both of these map to a lowercase, single underscore) */ #else #error 'Unrecognized Fortran name mapping' #endif /* Prototypes to keep compilers happy */ MPI_Fint c2fcomm_( MPI_Fint * ); MPI_Fint c2fgroup_( MPI_Fint * ); MPI_Fint c2finfo_( MPI_Fint * ); MPI_Fint c2frequest_( MPI_Fint * ); MPI_Fint c2ftype_( MPI_Fint * ); MPI_Fint c2fop_( MPI_Fint * ); MPI_Fint c2ferrhandler_( MPI_Fint * ); void f2ccomm_( MPI_Fint * ); void f2cgroup_( MPI_Fint * ); void f2cinfo_( MPI_Fint * ); void f2crequest_( MPI_Fint * ); void f2ctype_( MPI_Fint * ); void f2cop_( MPI_Fint * ); void f2cerrhandler_( MPI_Fint * ); MPI_Fint c2fcomm_ (MPI_Fint *comm) { MPI_Comm cComm = MPI_Comm_f2c(*comm); int cSize, wSize, cRank, wRank; MPI_Comm_size( MPI_COMM_WORLD, &wSize ); MPI_Comm_rank( MPI_COMM_WORLD, &wRank ); MPI_Comm_size( cComm, &cSize ); MPI_Comm_rank( cComm, &cRank ); if (wSize != cSize || wRank != cRank) { fprintf( stderr, "Comm: Did not get expected size,rank (got %d,%d)", cSize, cRank ); return 1; } return 0; } MPI_Fint c2fgroup_ (MPI_Fint *group) { MPI_Group cGroup = MPI_Group_f2c(*group); int cSize, wSize, cRank, wRank; /* We pass in the group of comm world */ MPI_Comm_size( MPI_COMM_WORLD, &wSize ); MPI_Comm_rank( MPI_COMM_WORLD, &wRank ); MPI_Group_size( cGroup, &cSize ); MPI_Group_rank( cGroup, &cRank ); if (wSize != cSize || wRank != cRank) { fprintf( stderr, "Group: Did not get expected size,rank (got %d,%d)", cSize, cRank ); return 1; } return 0; } MPI_Fint c2ftype_ ( MPI_Fint *type ) { MPI_Datatype dtype = MPI_Type_f2c( *type ); if (dtype != MPI_INTEGER) { fprintf( stderr, "Type: Did not get expected type\n" ); return 1; } return 0; } MPI_Fint c2finfo_ ( MPI_Fint *info ) { MPI_Info cInfo = MPI_Info_f2c( *info ); int flag; char value[100]; MPI_Fint errs = 0; MPI_Info_get( cInfo, (char*)"host", sizeof(value), value, &flag ); if (!flag || strcmp(value,"myname") != 0) { fprintf( stderr, "Info: Wrong value or no value for host\n" ); errs++; } MPI_Info_get( cInfo, (char*)"wdir", sizeof(value), value, &flag ); if (!flag || strcmp( value, "/rdir/foo" ) != 0) { fprintf( stderr, "Info: Wrong value of no value for wdir\n" ); errs++; } return errs; } MPI_Fint c2frequest_ ( MPI_Fint *request ) { MPI_Request req = MPI_Request_f2c( *request ); MPI_Status status; int flag; MPI_Test( &req, &flag, &status ); MPI_Test_cancelled( &status, &flag ); if (!flag) { fprintf( stderr, "Request: Wrong value for flag\n" ); return 1; } else { *request = MPI_Request_c2f( req ); } return 0; } MPI_Fint c2fop_ ( MPI_Fint *op ) { MPI_Op cOp = MPI_Op_f2c( *op ); if (cOp != MPI_SUM) { fprintf( stderr, "Op: did not get sum\n" ); return 1; } return 0; } MPI_Fint c2ferrhandler_ ( MPI_Fint *errh ) { MPI_Errhandler errhand = MPI_Errhandler_f2c( *errh ); if (errhand != MPI_ERRORS_RETURN) { fprintf( stderr, "Errhandler: did not get errors return\n" ); return 1; } return 0; } /* * The following routines provide handles to the calling Fortran program */ void f2ccomm_( MPI_Fint * comm ) { *comm = MPI_Comm_c2f( MPI_COMM_WORLD ); } void f2cgroup_( MPI_Fint * group ) { MPI_Group wgroup; MPI_Comm_group( MPI_COMM_WORLD, &wgroup ); *group = MPI_Group_c2f( wgroup ); } void f2ctype_( MPI_Fint * type ) { *type = MPI_Type_c2f( MPI_INTEGER ); } void f2cinfo_( MPI_Fint * info ) { MPI_Info cinfo; MPI_Info_create( &cinfo ); MPI_Info_set( cinfo, (char*)"host", (char*)"myname" ); MPI_Info_set( cinfo, (char*)"wdir", (char*)"/rdir/foo" ); *info = MPI_Info_c2f( cinfo ); } void f2crequest_( MPI_Fint * req ) { MPI_Request cReq; MPI_Irecv( NULL, 0, MPI_INT, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &cReq ); MPI_Cancel( &cReq ); *req = MPI_Request_c2f( cReq ); } void f2cop_( MPI_Fint * op ) { *op = MPI_Op_c2f( MPI_SUM ); } void f2cerrhandler_( MPI_Fint *errh ) { *errh = MPI_Errhandler_c2f( MPI_ERRORS_RETURN ); } SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/ext/ctypesinf.f000644 001750 001750 00000003163 12342443662 022540 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2010 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main include 'mpif.h' integer ierr integer errs, wrank integer f2ctype C call mtest_init( ierr ) call mpi_comm_rank( MPI_COMM_WORLD, wrank, ierr ) C errs = 0 C errs = errs + f2ctype( MPI_CHAR, 0 ) errs = errs + f2ctype( MPI_SIGNED_CHAR, 1 ) errs = errs + f2ctype( MPI_UNSIGNED_CHAR, 2 ) errs = errs + f2ctype( MPI_WCHAR, 3 ) errs = errs + f2ctype( MPI_SHORT, 4 ) errs = errs + f2ctype( MPI_UNSIGNED_SHORT, 5 ) errs = errs + f2ctype( MPI_INT, 6 ) errs = errs + f2ctype( MPI_UNSIGNED, 7 ) errs = errs + f2ctype( MPI_LONG, 8 ) errs = errs + f2ctype( MPI_UNSIGNED_LONG, 9 ) errs = errs + f2ctype( MPI_FLOAT, 10 ) errs = errs + f2ctype( MPI_DOUBLE, 11 ) errs = errs + f2ctype( MPI_FLOAT_INT, 12 ) errs = errs + f2ctype( MPI_DOUBLE_INT, 13 ) errs = errs + f2ctype( MPI_LONG_INT, 14 ) errs = errs + f2ctype( MPI_SHORT_INT, 15 ) errs = errs + f2ctype( MPI_2INT, 16 ) if (MPI_LONG_DOUBLE .ne. MPI_TYPE_NULL) then errs = errs + f2ctype( MPI_LONG_DOUBLE, 17 ) errs = errs + f2ctype( MPI_LONG_DOUBLE_INT, 21 ) endif if (MPI_LONG_LONG .ne. MPI_TYPE_NULL) then errs = errs + f2ctype( MPI_LONG_LONG_INT, 18 ) errs = errs + f2ctype( MPI_LONG_LONG, 19 ) errs = errs + f2ctype( MPI_UNSIGNED_LONG_LONG, 20 ) endif C C Summarize the errors C call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/ext/testlist000644 001750 001750 00000000043 12342443666 022161 0ustar00cici000000 000000 #c2f2cf 1 #c2fmult 1 #ctypesinf 1 SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/ext/add1size.h000644 001750 001750 00000000215 12342443662 022235 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C integer asize SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/ext/allocmemf.f000644 001750 001750 00000002243 12342443662 022471 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2004 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' C C This program makes use of a common (but not universal; g77 doesn't C have it) extension: the "Cray" pointer. This allows MPI_Alloc_mem C to allocate memory and return it to Fortran, where it can be used. C As this is not standard Fortran, this test is not run by default. C To run it, build (with a suitable compiler) and run with C mpiexec -n 1 ./allocmemf C real a pointer (p,a(100,100)) include 'add1size.h' integer ierr, sizeofreal, errs integer i,j C errs = 0 call mtest_init(ierr) call mpi_type_size( MPI_REAL, sizeofreal, ierr ) C Make sure we pass in an integer of the correct type asize = sizeofreal * 100 * 100 call mpi_alloc_mem( asize,MPI_INFO_NULL,p,ierr ) do i=1,100 do j=1,100 a(i,j) = -1 enddo enddo a(3,5) = 10.0 call mpi_free_mem( a, ierr ) call mtest_finalize(errs) call mpi_finalize(ierr) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/ext/c2f2cf.f000644 001750 001750 00000007214 12342443662 021602 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer errs, toterrs, ierr integer wrank, wsize integer wgroup, info, req integer fsize, frank integer comm, group, type, op, errh, result integer c2fcomm, c2fgroup, c2ftype, c2finfo, c2frequest, $ c2ferrhandler, c2fop character value*100 logical flag errs = 0 call mpi_init( ierr ) C C Test passing a Fortran MPI object to C call mpi_comm_rank( MPI_COMM_WORLD, wrank, ierr ) errs = errs + c2fcomm( MPI_COMM_WORLD ) call mpi_comm_group( MPI_COMM_WORLD, wgroup, ierr ) errs = errs + c2fgroup( wgroup ) call mpi_group_free( wgroup, ierr ) call mpi_info_create( info, ierr ) call mpi_info_set( info, "host", "myname", ierr ) call mpi_info_set( info, "wdir", "/rdir/foo", ierr ) errs = errs + c2finfo( info ) call mpi_info_free( info, ierr ) errs = errs + c2ftype( MPI_INTEGER ) call mpi_irecv( 0, 0, MPI_INTEGER, MPI_ANY_SOURCE, MPI_ANY_TAG, $ MPI_COMM_WORLD, req, ierr ) call mpi_cancel( req, ierr ) errs = errs + c2frequest( req ) call mpi_wait( req, MPI_STATUS_IGNORE, ierr ) errs = errs + c2ferrhandler( MPI_ERRORS_RETURN ) errs = errs + c2fop( MPI_SUM ) C C Test using a C routine to provide the Fortran handle call mpi_comm_size( MPI_COMM_WORLD, wsize, ierr ) call mpi_comm_rank( MPI_COMM_WORLD, wrank, ierr ) call f2ccomm( comm ) call mpi_comm_size( comm, fsize, ierr ) call mpi_comm_rank( comm, frank, ierr ) if (fsize.ne.wsize .or. frank.ne.wrank) then errs = errs + 1 print *, "Comm(fortran) has wrong size or rank" endif call f2cgroup( group ) call mpi_group_size( group, fsize, ierr ) call mpi_group_rank( group, frank, ierr ) if (fsize.ne.wsize .or. frank.ne.wrank) then errs = errs + 1 print *, "Group(fortran) has wrong size or rank" endif call mpi_group_free( group, ierr ) call f2ctype( type ) if (type .ne. MPI_INTEGER) then errs = errs + 1 print *, "Datatype(fortran) is not MPI_INT" endif call f2cinfo( info ) call mpi_info_get( info, "host", 100, value, flag, ierr ) if (.not. flag) then errs = errs + 1 print *, "Info test for host returned false" else if (value .ne. "myname") then errs = errs + 1 print *, "Info test for host returned ", value endif call mpi_info_get( info, "wdir", 100, value, flag, ierr ) if (.not. flag) then errs = errs + 1 print *, "Info test for wdir returned false" else if (value .ne. "/rdir/foo") then errs = errs + 1 print *, "Info test for wdir returned ", value endif call mpi_info_free( info, ierr ) call f2cop( op ) if (op .ne. MPI_SUM) then errs = errs + 1 print *, "Fortran MPI_SUM not MPI_SUM in C" endif call f2cerrhandler( errh ) if (errh .ne. MPI_ERRORS_RETURN) then errs = errs + 1 print *,"Fortran MPI_ERRORS_RETURN not MPI_ERRORS_RETURN in C" endif C C Summarize the errors C call mpi_allreduce( errs, toterrs, 1, MPI_INTEGER, MPI_SUM, $ MPI_COMM_WORLD, ierr ) if (wrank .eq. 0) then if (toterrs .eq. 0) then print *, ' No Errors' else print *, ' Found ', toterrs, ' errors' endif endif call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/ext/c2fmult.c000644 001750 001750 00000003165 12342443662 022107 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* Check that MPI_xxxx_c2f, applied to the same object several times, yields the same handle. We do this because when MPI handles in C are a different length than those in Fortran, care needs to be exercised to ensure that the mapping from one to another is unique. (Test added to test a potential problem in ROMIO for handling MPI_File on 64-bit systems) */ #include "mpi.h" #include #include "mpitest.h" int main( int argc, char *argv[] ) { MPI_Fint handleA, handleB; int rc; int errs = 0; int buf[1]; MPI_Request cRequest; MPI_Status st; int tFlag; MTest_Init( &argc, &argv ); /* Request */ rc = MPI_Irecv( buf, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &cRequest ); if (rc) { errs++; printf( "Unable to create request\n" ); } else { handleA = MPI_Request_c2f( cRequest ); handleB = MPI_Request_c2f( cRequest ); if (handleA != handleB) { errs++; printf( "MPI_Request_c2f does not give the same handle twice on the same MPI_Request\n" ); } } MPI_Cancel( &cRequest ); MPI_Test( &cRequest, &tFlag, &st ); MPI_Test_cancelled( &st, &tFlag ); if (!tFlag) { errs++; printf( "Unable to cancel MPI_Irecv request\n" ); } /* Using MPI_Request_free should be ok, but some MPI implementations object to it imediately after the cancel and that isn't essential to this test */ MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/ext/ctypesfromc.c000644 001750 001750 00000010162 12342443662 023064 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2008 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* * This file contains the C routines used in testing that all C datatypes * are available in Fortran and have the correct values. * * The tests follow this pattern: * * Fortran main program * calls the c routine f2ctype with each of the C types and the name of * the type. That c routine using MPI_Type_f2c to convert the * Fortran handle to a C handle, and then compares it to the corresponding * C type, which is found by looking up the C handle by name * * C routine uses xxx_f2c routine to get C handle, checks some * properties (i.e., size and rank of communicator, contents of datatype) * * Then the Fortran main program calls a C routine that provides * a handle, and the Fortran program performs similar checks. * * We also assume that a C int is a Fortran integer. If this is not the * case, these tests must be modified. */ /* style: allow:fprintf:10 sig:0 */ #include #include "mpi.h" #include "../../include/mpitestconf.h" #include /* Create an array with all of the MPI names in it */ /* This is extracted from the test in test/mpi/types/typename.c ; only the C types are included. */ typedef struct mpi_names_t { MPI_Datatype dtype; const char *name; } mpi_names_t; /* The MPI standard specifies that the names must be the MPI names, not the related language names (e.g., MPI_CHAR, not char) */ static mpi_names_t mpi_names[] = { { MPI_CHAR, "MPI_CHAR" }, { MPI_SIGNED_CHAR, "MPI_SIGNED_CHAR" }, { MPI_UNSIGNED_CHAR, "MPI_UNSIGNED_CHAR" }, { MPI_WCHAR, "MPI_WCHAR" }, { MPI_SHORT, "MPI_SHORT" }, { MPI_UNSIGNED_SHORT, "MPI_UNSIGNED_SHORT" }, { MPI_INT, "MPI_INT" }, { MPI_UNSIGNED, "MPI_UNSIGNED" }, { MPI_LONG, "MPI_LONG" }, { MPI_UNSIGNED_LONG, "MPI_UNSIGNED_LONG" }, { MPI_FLOAT, "MPI_FLOAT" }, { MPI_DOUBLE, "MPI_DOUBLE" }, { MPI_FLOAT_INT, "MPI_FLOAT_INT" }, { MPI_DOUBLE_INT, "MPI_DOUBLE_INT" }, { MPI_LONG_INT, "MPI_LONG_INT" }, { MPI_SHORT_INT, "MPI_SHORT_INT" }, { MPI_2INT, "MPI_2INT" }, { MPI_LONG_DOUBLE, "MPI_LONG_DOUBLE" }, { MPI_LONG_LONG_INT, "MPI_LONG_LONG_INT" }, { MPI_LONG_LONG, "MPI_LONG_LONG" }, { MPI_UNSIGNED_LONG_LONG, "MPI_UNSIGNED_LONG_LONG" }, { MPI_LONG_DOUBLE_INT, "MPI_LONG_DOUBLE_INT" }, { 0, (char *)0 }, /* Sentinal used to indicate the last element */ }; /* Name mapping. All routines are created with names that are lower case with a single trailing underscore. This matches many compilers. We use #define to change the name for Fortran compilers that do not use the lowercase/underscore pattern */ #ifdef F77_NAME_UPPER #define f2ctype_ F2CTYPE #elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED) /* Mixed is ok because we use lowercase in all uses */ #define f2ctype_ f2ctype #elif defined(F77_NAME_LOWER_2USCORE) || defined(F77_NAME_LOWER_USCORE) || \ defined(F77_NAME_MIXED_USCORE) /* Else leave name alone (routines have no underscore, so both of these map to a lowercase, single underscore) */ #else #error 'Unrecognized Fortran name mapping' #endif /* Prototypes to keep compilers happy */ int f2ctype_( MPI_Fint *, MPI_Fint * ); /* */ int f2ctype_( MPI_Fint *fhandle, MPI_Fint *typeidx ) { int errs = 0; MPI_Datatype ctype; /* printf( "Testing %s\n", mpi_names[*typeidx].name ); */ ctype = MPI_Type_f2c( *fhandle ); if (ctype != mpi_names[*typeidx].dtype) { char mytypename[MPI_MAX_OBJECT_NAME]; int mytypenamelen; /* An implementation is not *required* to deliver the corresponding C version of the MPI Datatype bit-for-bit. But if *must* act like it - e.g., the datatype name must be the same */ MPI_Type_get_name( ctype, mytypename, &mytypenamelen ); if (strcmp( mytypename, mpi_names[*typeidx].name ) != 0) { errs++; printf( "C and Fortran types for %s (c name is %s) do not match f=%d, ctof=%d.\n", mpi_names[*typeidx].name, mytypename, *fhandle, MPI_Type_c2f( ctype ) ); } } return errs; } SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/ext/CMakeLists.txt000644 001750 001750 00000002630 12342443654 023124 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite AND SMPI_F2C) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include/") # add_executable(allocmemf allocmemf.f) # add_executable(c2f2cf c2f2cf.f c2f2c.c) # add_executable(ctypesinf ctypesinf.f ctypesfromc.c) # target_link_libraries(allocmemf simgrid mtest_f77) # target_link_libraries(c2f2cf simgrid mtest_f77) # target_link_libraries(ctypesinf simgrid mtest_f77) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/add1size.h ${CMAKE_CURRENT_SOURCE_DIR}/allocmemf.f ${CMAKE_CURRENT_SOURCE_DIR}/c2f2c.c ${CMAKE_CURRENT_SOURCE_DIR}/c2f2cf.f ${CMAKE_CURRENT_SOURCE_DIR}/c2fmult.c ${CMAKE_CURRENT_SOURCE_DIR}/ctypesfromc.c ${CMAKE_CURRENT_SOURCE_DIR}/ctypesinf.f PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/testlist000644 001750 001750 00000000102 12342443666 021355 0ustar00cici000000 000000 #attr coll datatype pt2pt #info #spawn #io # init #comm ext #topo SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/init/000755 001750 001750 00000000000 12342443666 020531 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/init/testlist000644 001750 001750 00000000013 12342443666 022321 0ustar00cici000000 000000 baseenvf 1 SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/init/checksizes.c000644 001750 001750 00000001125 12342443662 023023 0ustar00cici000000 000000 #include "mpi.h" #include int main( int argc, char **argv ) { int fsizeof_aint = ; int fsizeof_offset = ; int err = 0, rc = 0; MPI_Init( &argc, &argv ); if (sizeof(MPI_Aint) != fsizeof_aint) { printf( "Sizeof MPI_Aint is %d but Fortran thinks it is %d\n", (int)sizeof(MPI_Aint), fsizeof_aint ); err++; } if (sizeof(MPI_Offset) != fsizeof_offset) { printf( "Sizeof MPI_Offset is %d but Fortran thinks it is %d\n", (int)sizeof(MPI_Offset), fsizeof_offset ); err++; } MPI_Finalize( ); if (err > 0) rc = 1; return rc; } SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/init/baseenvf.f000644 001750 001750 00000005307 12342443662 022472 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer ierr, provided, errs, rank, size integer iv, isubv, qprovided logical flag errs = 0 flag = .true. call mpi_finalized( flag, ierr ) if (flag) then errs = errs + 1 print *, 'Returned true for finalized before init' endif flag = .true. call mpi_initialized( flag, ierr ) if (flag) then errs = errs + 1 print *, 'Return true for initialized before init' endif provided = -1 call mpi_init_thread( MPI_THREAD_MULTIPLE, provided, ierr ) if (provided .ne. MPI_THREAD_MULTIPLE .and. & provided .ne. MPI_THREAD_SERIALIZED .and. & provided .ne. MPI_THREAD_FUNNELED .and. & provided .ne. MPI_THREAD_SINGLE) then errs = errs + 1 print *, ' Unrecognized value for provided = ', provided endif iv = -1 isubv = -1 call mpi_get_version( iv, isubv, ierr ) if (iv .ne. MPI_VERSION .or. isubv .ne. MPI_SUBVERSION) then errs = errs + 1 print *, 'Version in mpif.h and get_version do not agree' print *, 'Version in mpif.h is ', MPI_VERSION, '.', & MPI_SUBVERSION print *, 'Version in get_version is ', iv, '.', isubv endif if (iv .lt. 1 .or. iv .gt. 3) then errs = errs + 1 print *, 'Version of MPI is invalid (=', iv, ')' endif if (isubv.lt.0 .or. isubv.gt.2) then errs = errs + 1 print *, 'Subversion of MPI is invalid (=', isubv, ')' endif call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) call mpi_comm_size( MPI_COMM_WORLD, size, ierr ) flag = .false. call mpi_is_thread_main( flag, ierr ) if (.not.flag) then errs = errs + 1 print *, 'is_thread_main returned false for main thread' endif call mpi_query_thread( qprovided, ierr ) if (qprovided .ne. provided) then errs = errs + 1 print *,'query thread and init thread disagree on'// & ' thread level' endif call mpi_finalize( ierr ) flag = .false. call mpi_finalized( flag, ierr ) if (.not. flag) then errs = errs + 1 print *, 'finalized returned false after finalize' endif if (rank .eq. 0) then if (errs .eq. 0) then print *, ' No Errors' else print *, ' Found ', errs, ' errors' endif endif end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/init/CMakeLists.txt000644 001750 001750 00000001775 12342443654 023300 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite AND SMPI_F2C) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include/") add_executable(baseenvf baseenvf.f) target_link_libraries(baseenvf simgrid mtest_f77) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/baseenvf.f ${CMAKE_CURRENT_SOURCE_DIR}/checksizes.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/000755 001750 001750 00000000000 12342443666 021401 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/hindexed_blockf.f000644 001750 001750 00000012761 12342443662 024663 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer errs, ierr, i, intsize integer type1, type2, type3, type4, type5 integer max_asizev parameter (max_asizev = 10) include 'typeaints.h' integer blocklens(max_asizev), dtypes(max_asizev) integer displs(max_asizev) integer recvbuf(6*max_asizev) integer sendbuf(max_asizev), status(MPI_STATUS_SIZE) integer rank, size errs = 0 call mtest_init( ierr ) call mpi_comm_size( MPI_COMM_WORLD, size, ierr ) call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) C call mpi_type_size( MPI_INTEGER, intsize, ierr ) C aintv(1) = 0 aintv(2) = 3 * intsize call mpi_type_create_resized( MPI_INTEGER, aintv(1), aintv(2), & type1, ierr ) call mpi_type_commit( type1, ierr ) aintv(1) = -1 aintv(2) = -1 call mpi_type_get_extent( type1, aintv(1), aintv(2), ierr ) if (aintv(1) .ne. 0) then errs = errs + 1 print *, 'Did not get expected lb' endif if (aintv(2) .ne. 3*intsize) then errs = errs + 1 print *, 'Did not get expected extent' endif aintv(1) = -1 aintv(2) = -1 call mpi_type_get_true_extent( type1, aintv(1), aintv(2), ierr ) if (aintv(1) .ne. 0) then errs = errs + 1 print *, 'Did not get expected true lb' endif if (aintv(2) .ne. intsize) then errs = errs + 1 print *, 'Did not get expected true extent (', aintv(2), ') ', & ' expected ', intsize endif C do i=1,10 blocklens(i) = 1 aintv(i) = (i-1) * 3 * intsize enddo call mpi_type_create_hindexed( 10, blocklens, aintv, & MPI_INTEGER, type2, ierr ) call mpi_type_commit( type2, ierr ) C aint = 3 * intsize call mpi_type_create_hvector( 10, 1, aint, MPI_INTEGER, type3, & ierr ) call mpi_type_commit( type3, ierr ) C do i=1,10 blocklens(i) = 1 dtypes(i) = MPI_INTEGER aintv(i) = (i-1) * 3 * intsize enddo call mpi_type_create_struct( 10, blocklens, aintv, dtypes, & type4, ierr ) call mpi_type_commit( type4, ierr ) call mpi_type_get_extent(MPI_INTEGER, aintv(1), aint, ierr) do i=1,10 aintv(i) = (i-1) * 3 * aint enddo call mpi_type_create_hindexed_block( 10, 1, aintv, & MPI_INTEGER, type5, ierr ) call mpi_type_commit( type5, ierr ) C C Using each time, send and receive using these types do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & recvbuf, max_asizev, type1, rank, 0, & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type1:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo C do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & recvbuf, 1, type2, rank, 0, & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type2:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo C do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & recvbuf, 1, type3, rank, 0, & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type3:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo C do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & recvbuf, 1, type4, rank, 0, & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type4:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo C do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & recvbuf, 1, type5, rank, 0, & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type5:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo C call mpi_type_free( type1, ierr ) call mpi_type_free( type2, ierr ) call mpi_type_free( type3, ierr ) call mpi_type_free( type4, ierr ) call mpi_type_free( type5, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/testlist000644 001750 001750 00000000256 12342443666 023202 0ustar00cici000000 000000 #typenamef 1 #typename3f 1 mpiversion=3.0 #typesnamef 1 #typecntsf 1 #typem2f 1 #typesubf 1 #packef 1 gaddressf 1 #allctypesf 1 #hindex1f 1 #hindexed_blockf 1 mpiversion=3.0 SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/packef.f000644 001750 001750 00000015107 12342443662 023001 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer ierr, errs integer inbuf(10), ioutbuf(10), inbuf2(10), ioutbuf2(10) integer i, insize, rsize, csize, insize2 character*(16) cbuf, coutbuf double precision rbuf(10), routbuf(10) integer packbuf(1000), pbufsize, intsize integer max_asizev parameter (max_asizev = 3) include 'typeaints.h' errs = 0 call mtest_init( ierr ) call mpi_type_size( MPI_INTEGER, intsize, ierr ) pbufsize = 1000 * intsize call mpi_pack_external_size( 'external32', 10, MPI_INTEGER, & aint, ierr ) if (aint .ne. 10 * 4) then errs = errs + 1 print *, 'Expected 40 for size of 10 external32 integers', & ', got ', aint endif call mpi_pack_external_size( 'external32', 10, MPI_LOGICAL, & aint, ierr ) if (aint .ne. 10 * 4) then errs = errs + 1 print *, 'Expected 40 for size of 10 external32 logicals', & ', got ', aint endif call mpi_pack_external_size( 'external32', 10, MPI_CHARACTER, & aint, ierr ) if (aint .ne. 10 * 1) then errs = errs + 1 print *, 'Expected 10 for size of 10 external32 characters', & ', got ', aint endif call mpi_pack_external_size( 'external32', 3, MPI_INTEGER2, & aint, ierr ) if (aint .ne. 3 * 2) then errs = errs + 1 print *, 'Expected 6 for size of 3 external32 INTEGER*2', & ', got ', aint endif call mpi_pack_external_size( 'external32', 3, MPI_INTEGER4, & aint, ierr ) if (aint .ne. 3 * 4) then errs = errs + 1 print *, 'Expected 12 for size of 3 external32 INTEGER*4', & ', got ', aint endif call mpi_pack_external_size( 'external32', 3, MPI_REAL4, & aint, ierr ) if (aint .ne. 3 * 4) then errs = errs + 1 print *, 'Expected 12 for size of 3 external32 REAL*4', & ', got ', aint endif call mpi_pack_external_size( 'external32', 3, MPI_REAL8, & aint, ierr ) if (aint .ne. 3 * 8) then errs = errs + 1 print *, 'Expected 24 for size of 3 external32 REAL*8', & ', got ', aint endif if (MPI_INTEGER1 .ne. MPI_DATATYPE_NULL) then call mpi_pack_external_size( 'external32', 3, MPI_INTEGER1, & aint, ierr ) if (aint .ne. 3 * 1) then errs = errs + 1 print *, 'Expected 3 for size of 3 external32 INTEGER*1', & ', got ', aint endif endif if (MPI_INTEGER8 .ne. MPI_DATATYPE_NULL) then call mpi_pack_external_size( 'external32', 3, MPI_INTEGER8, & aint, ierr ) if (aint .ne. 3 * 8) then errs = errs + 1 print *, 'Expected 24 for size of 3 external32 INTEGER*8', & ', got ', aint endif endif C C Initialize values C insize = 10 do i=1, insize inbuf(i) = i enddo rsize = 3 do i=1, rsize rbuf(i) = 1000.0 * i enddo cbuf = 'This is a string' csize = 16 insize2 = 7 do i=1, insize2 inbuf2(i) = 5000-i enddo C aintv(1) = pbufsize aintv(2) = 0 aintv(3) = 0 C One MPI implementation failed to increment the position; instead, C it set the value with the amount of data packed in this call C We use aintv(3) to detect and report this specific error call mpi_pack_external( 'external32', inbuf, insize, MPI_INTEGER, & packbuf, aintv(1), aintv(2), ierr ) if (aintv(2) .le. aintv(3)) then print *, ' Position decreased after pack of integer!' endif aintv(3) = aintv(2) call mpi_pack_external( 'external32', rbuf, rsize, & MPI_DOUBLE_PRECISION, packbuf, aintv(1), & aintv(2), ierr ) if (aintv(2) .le. aintv(3)) then print *, ' Position decreased after pack of real!' endif aintv(3) = aintv(2) call mpi_pack_external( 'external32', cbuf, csize, & MPI_CHARACTER, packbuf, aintv(1), & aintv(2), ierr ) if (aintv(2) .le. aintv(3)) then print *, ' Position decreased after pack of character!' endif aintv(3) = aintv(2) call mpi_pack_external( 'external32', inbuf2, insize2, & MPI_INTEGER, & packbuf, aintv(1), aintv(2), ierr ) if (aintv(2) .le. aintv(3)) then print *, ' Position decreased after pack of integer (2nd)!' endif aintv(3) = aintv(2) C C We could try sending this with MPI_BYTE... aintv(2) = 0 call mpi_unpack_external( 'external32', packbuf, aintv(1), & aintv(2), ioutbuf, insize, MPI_INTEGER, ierr ) call mpi_unpack_external( 'external32', packbuf, aintv(1), & aintv(2), routbuf, rsize, MPI_DOUBLE_PRECISION, ierr ) call mpi_unpack_external( 'external32', packbuf, aintv(1), & aintv(2), coutbuf, csize, MPI_CHARACTER, ierr ) call mpi_unpack_external( 'external32', packbuf, aintv(1), & aintv(2), ioutbuf2, insize2, MPI_INTEGER, ierr ) C C Now, test the values C do i=1, insize if (ioutbuf(i) .ne. i) then errs = errs + 1 print *, 'ioutbuf(',i,') = ', ioutbuf(i), ' expected ', i endif enddo do i=1, rsize if (routbuf(i) .ne. 1000.0 * i) then errs = errs + 1 print *, 'routbuf(',i,') = ', routbuf(i), ' expected ', & & 1000.0 * i endif enddo if (coutbuf(1:csize) .ne. 'This is a string') then errs = errs + 1 print *, 'coutbuf = ', coutbuf(1:csize), ' expected ', & & 'This is a string' endif do i=1, insize2 if (ioutbuf2(i) .ne. 5000-i) then errs = errs + 1 print *, 'ioutbuf2(',i,') = ', ioutbuf2(i), ' expected ', & & 5000-i endif enddo C call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/gaddressf.f000644 001750 001750 00000001662 12342443662 023513 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer max_asizev parameter (max_asizev=2) include 'typeaints.h' integer iarray(200), gap, intsize integer ierr, errs errs = 0 call MPI_Init(ierr) call MPI_Get_address( iarray(1), aintv(1), ierr ) call MPI_Get_address( iarray(200), aintv(2), ierr ) gap = aintv(2) - aintv(1) call MPI_Type_size( MPI_INTEGER, intsize, ierr ) if (gap .ne. 199 * intsize) then errs = errs + 1 print *, ' Using get_address, computed a gap of ', gap print *, ' Expected a gap of ', 199 * intsize endif if (errs .gt. 0) then print *, ' Found ', errs, ' errors' else print *, ' No Errors' endif call MPI_Finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/typesubf.f000644 001750 001750 00000004165 12342443662 023413 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer errs, ierr integer maxn, maxm parameter (maxn=10,maxm=15) integer fullsizes(2), subsizes(2), starts(2) integer fullarr(maxn,maxm),subarr(maxn-3,maxm-4) integer i,j, ssize integer newtype, size, rank, ans errs = 0 call mtest_init( ierr ) call mpi_comm_size( MPI_COMM_WORLD, size, ierr ) call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) C C Create a Fortran-style subarray fullsizes(1) = maxn fullsizes(2) = maxm subsizes(1) = maxn - 3 subsizes(2) = maxm - 4 C starts are from zero, even in Fortran starts(1) = 1 starts(2) = 2 C In Fortran 90 notation, the original array is C integer a(maxn,maxm) C and the subarray is C a(1+1:(maxn-3) +(1+1)-1,2+1:(maxm-4)+(2+1)-1) C i.e., a (start:(len + start - 1),...) call mpi_type_create_subarray( 2, fullsizes, subsizes, starts, & MPI_ORDER_FORTRAN, MPI_INTEGER, newtype, ierr ) call mpi_type_commit( newtype, ierr ) C C Prefill the array do j=1, maxm do i=1, maxn fullarr(i,j) = (i-1) + (j-1) * maxn enddo enddo do j=1, subsizes(2) do i=1, subsizes(1) subarr(i,j) = -1 enddo enddo ssize = subsizes(1)*subsizes(2) call mpi_sendrecv( fullarr, 1, newtype, rank, 0, & subarr, ssize, MPI_INTEGER, rank, 0, & MPI_COMM_WORLD, MPI_STATUS_IGNORE, ierr ) C C Check the data do j=1, subsizes(2) do i=1, subsizes(1) ans = (i+starts(1)-1) + (j+starts(2)-1) * maxn if (subarr(i,j) .ne. ans) then errs = errs + 1 if (errs .le. 10) then print *, rank, 'subarr(',i,',',j,') = ', subarr(i,j) endif endif enddo enddo call mpi_type_free( newtype, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/typenamef.f000644 001750 001750 00000016340 12342443662 023540 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' character*(MPI_MAX_OBJECT_NAME) name integer namelen integer ierr, errs errs = 0 call mtest_init( ierr ) C C Check each Fortran datatype, including the size-specific ones C See the C version (typename.c) for the relevant MPI sections call MPI_Type_get_name( MPI_COMPLEX, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_COMPLEX") then errs = errs + 1 print *, "Expected MPI_COMPLEX but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_DOUBLE_COMPLEX, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_DOUBLE_COMPLEX") then errs = errs + 1 print *, "Expected MPI_DOUBLE_COMPLEX but got "// & name(1:namelen) endif call MPI_Type_get_name( MPI_LOGICAL, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_LOGICAL") then errs = errs + 1 print *, "Expected MPI_LOGICAL but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_REAL, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_REAL") then errs = errs + 1 print *, "Expected MPI_REAL but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_DOUBLE_PRECISION, name, namelen, ierr) if (name(1:namelen) .ne. "MPI_DOUBLE_PRECISION") then errs = errs + 1 print *, "Expected MPI_DOUBLE_PRECISION but got "// & name(1:namelen) endif call MPI_Type_get_name( MPI_INTEGER, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_INTEGER") then errs = errs + 1 print *, "Expected MPI_INTEGER but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_2INTEGER, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_2INTEGER") then errs = errs + 1 print *, "Expected MPI_2INTEGER but got "//name(1:namelen) endif C 2COMPLEX was present only in MPI 1.0 C call MPI_Type_get_name( MPI_2COMPLEX, name, namelen, ierr ) C if (name(1:namelen) .ne. "MPI_2COMPLEX") then C errs = errs + 1 C print *, "Expected MPI_2COMPLEX but got "//name(1:namelen) C endif C call MPI_Type_get_name(MPI_2DOUBLE_PRECISION, name, namelen, ierr) if (name(1:namelen) .ne. "MPI_2DOUBLE_PRECISION") then errs = errs + 1 print *, "Expected MPI_2DOUBLE_PRECISION but got "// & name(1:namelen) endif call MPI_Type_get_name( MPI_2REAL, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_2REAL") then errs = errs + 1 print *, "Expected MPI_2REAL but got "//name(1:namelen) endif C 2DOUBLE_COMPLEX isn't in MPI 2.1 C call MPI_Type_get_name( MPI_2DOUBLE_COMPLEX, name, namelen, ierr ) C if (name(1:namelen) .ne. "MPI_2DOUBLE_COMPLEX") then C errs = errs + 1 C print *, "Expected MPI_2DOUBLE_COMPLEX but got "// C & name(1:namelen) C endif call MPI_Type_get_name( MPI_CHARACTER, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_CHARACTER") then errs = errs + 1 print *, "Expected MPI_CHARACTER but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_BYTE, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_BYTE") then errs = errs + 1 print *, "Expected MPI_BYTE but got "//name(1:namelen) endif if (MPI_REAL4 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_REAL4, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_REAL4") then errs = errs + 1 print *, "Expected MPI_REAL4 but got "//name(1:namelen) endif endif if (MPI_REAL8 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_REAL8, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_REAL8") then errs = errs + 1 print *, "Expected MPI_REAL8 but got "//name(1:namelen) endif endif if (MPI_REAL16 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_REAL16, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_REAL16") then errs = errs + 1 print *, "Expected MPI_REAL16 but got "//name(1:namelen) endif endif if (MPI_COMPLEX8 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_COMPLEX8, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_COMPLEX8") then errs = errs + 1 print *, "Expected MPI_COMPLEX8 but got "// & name(1:namelen) endif endif if (MPI_COMPLEX16 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_COMPLEX16, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_COMPLEX16") then errs = errs + 1 print *, "Expected MPI_COMPLEX16 but got "// & name(1:namelen) endif endif if (MPI_COMPLEX32 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_COMPLEX32, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_COMPLEX32") then errs = errs + 1 print *, "Expected MPI_COMPLEX32 but got "// & name(1:namelen) endif endif if (MPI_INTEGER1 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_INTEGER1, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_INTEGER1") then errs = errs + 1 print *, "Expected MPI_INTEGER1 but got "// & name(1:namelen) endif endif if (MPI_INTEGER2 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_INTEGER2, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_INTEGER2") then errs = errs + 1 print *, "Expected MPI_INTEGER2 but got "// & name(1:namelen) endif endif if (MPI_INTEGER4 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_INTEGER4, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_INTEGER4") then errs = errs + 1 print *, "Expected MPI_INTEGER4 but got "// & name(1:namelen) endif endif if (MPI_INTEGER8 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_INTEGER8, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_INTEGER8") then errs = errs + 1 print *, "Expected MPI_INTEGER8 but got "// & name(1:namelen) endif endif C MPI_INTEGER16 is in MPI 2.1, but it is missing from most tables C Some MPI implementations may not provide it C if (MPI_INTEGER16 .ne. MPI_DATATYPE_NULL) then C call MPI_Type_get_name( MPI_INTEGER16, name, namelen, ierr ) C if (name(1:namelen) .ne. "MPI_INTEGER16") then C errs = errs + 1 C print *, "Expected MPI_INTEGER16 but got "// C & name(1:namelen) C endif C endif call mtest_finalize( errs ) call MPI_Finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/allctypesf.f000644 001750 001750 00000012655 12342443662 023723 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2004 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main include 'mpif.h' integer atype, ierr C call mtest_init(ierr) call mpi_comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN, * ierr ) C C Check that all Ctypes are available in Fortran (MPI 2.1, p 483, line 46) C call checkdtype( MPI_CHAR, "MPI_CHAR", ierr ) call checkdtype( MPI_SIGNED_CHAR, "MPI_SIGNED_CHAR", ierr ) call checkdtype( MPI_UNSIGNED_CHAR, "MPI_UNSIGNED_CHAR", ierr ) call checkdtype( MPI_BYTE, "MPI_BYTE", ierr ) call checkdtype( MPI_WCHAR, "MPI_WCHAR", ierr ) call checkdtype( MPI_SHORT, "MPI_SHORT", ierr ) call checkdtype( MPI_UNSIGNED_SHORT, "MPI_UNSIGNED_SHORT", ierr ) call checkdtype( MPI_INT, "MPI_INT", ierr ) call checkdtype( MPI_UNSIGNED, "MPI_UNSIGNED", ierr ) call checkdtype( MPI_LONG, "MPI_LONG", ierr ) call checkdtype( MPI_UNSIGNED_LONG, "MPI_UNSIGNED_LONG", ierr ) call checkdtype( MPI_FLOAT, "MPI_FLOAT", ierr ) call checkdtype( MPI_DOUBLE, "MPI_DOUBLE", ierr ) if (MPI_LONG_DOUBLE .ne. MPI_DATATYPE_NULL) then call checkdtype( MPI_LONG_DOUBLE, "MPI_LONG_DOUBLE", ierr ) endif if (MPI_LONG_LONG_INT .ne. MPI_DATATYPE_NULL) then call checkdtype2( MPI_LONG_LONG_INT, "MPI_LONG_LONG_INT", * "MPI_LONG_LONG", ierr ) endif if (MPI_UNSIGNED_LONG_LONG .ne. MPI_DATATYPE_NULL) then call checkdtype( MPI_UNSIGNED_LONG_LONG, * "MPI_UNSIGNED_LONG_LONG", ierr ) endif if (MPI_LONG_LONG .ne. MPI_DATATYPE_NULL) then call checkdtype2( MPI_LONG_LONG, "MPI_LONG_LONG", * "MPI_LONG_LONG_INT", ierr ) endif call checkdtype( MPI_PACKED, "MPI_PACKED", ierr ) call checkdtype( MPI_LB, "MPI_LB", ierr ) call checkdtype( MPI_UB, "MPI_UB", ierr ) call checkdtype( MPI_FLOAT_INT, "MPI_FLOAT_INT", ierr ) call checkdtype( MPI_DOUBLE_INT, "MPI_DOUBLE_INT", ierr ) call checkdtype( MPI_LONG_INT, "MPI_LONG_INT", ierr ) call checkdtype( MPI_SHORT_INT, "MPI_SHORT_INT", ierr ) call checkdtype( MPI_2INT, "MPI_2INT", ierr ) if (MPI_LONG_DOUBLE_INT .ne. MPI_DATATYPE_NULL) then call checkdtype( MPI_LONG_DOUBLE_INT, "MPI_LONG_DOUBLE_INT", * ierr) endif C C Check that all Ctypes are available in Fortran (MPI 2.2) C Note that because of implicit declarations in Fortran, this C code should compile even with pre MPI 2.2 implementations. C if (MPI_VERSION .gt. 2 .or. (MPI_VERSION .eq. 2 .and. * MPI_SUBVERSION .ge. 2)) then call checkdtype( MPI_INT8_T, "MPI_INT8_T", ierr ) call checkdtype( MPI_INT16_T, "MPI_INT16_T", ierr ) call checkdtype( MPI_INT32_T, "MPI_INT32_T", ierr ) call checkdtype( MPI_INT64_T, "MPI_INT64_T", ierr ) call checkdtype( MPI_UINT8_T, "MPI_UINT8_T", ierr ) call checkdtype( MPI_UINT16_T, "MPI_UINT16_T", ierr ) call checkdtype( MPI_UINT32_T, "MPI_UINT32_T", ierr ) call checkdtype( MPI_UINT64_T, "MPI_UINT64_T", ierr ) C other C99 types call checkdtype( MPI_C_BOOL, "MPI_C_BOOL", ierr ) call checkdtype( MPI_C_FLOAT_COMPLEX, "MPI_C_FLOAT_COMPLEX", * ierr) call checkdtype2( MPI_C_COMPLEX, "MPI_C_COMPLEX", * "MPI_C_FLOAT_COMPLEX", ierr ) call checkdtype( MPI_C_DOUBLE_COMPLEX, "MPI_C_DOUBLE_COMPLEX", * ierr ) if (MPI_C_LONG_DOUBLE_COMPLEX .ne. MPI_DATATYPE_NULL) then call checkdtype( MPI_C_LONG_DOUBLE_COMPLEX, * "MPI_C_LONG_DOUBLE_COMPLEX", ierr ) endif C address/offset types call checkdtype( MPI_AINT, "MPI_AINT", ierr ) call checkdtype( MPI_OFFSET, "MPI_OFFSET", ierr ) endif C call mtest_finalize( ierr ) call MPI_Finalize( ierr ) end C C Check name of datatype subroutine CheckDtype( intype, name, ierr ) include 'mpif.h' integer intype, ierr character *(*) name integer ir, rlen character *(MPI_MAX_OBJECT_NAME) outname C outname = "" call MPI_TYPE_GET_NAME( intype, outname, rlen, ir ) if (ir .ne. MPI_SUCCESS) then print *, " Datatype ", name, " not available in Fortran" ierr = ierr + 1 else if (outname .ne. name) then print *, " For datatype ", name, " found name ", * outname(1:rlen) ierr = ierr + 1 endif endif return end C C Check name of datatype (allows alias) subroutine CheckDtype2( intype, name, name2, ierr ) include 'mpif.h' integer intype, ierr character *(*) name, name2 integer ir, rlen character *(MPI_MAX_OBJECT_NAME) outname C outname = "" call MPI_TYPE_GET_NAME( intype, outname, rlen, ir ) if (ir .ne. MPI_SUCCESS) then print *, " Datatype ", name, " not available in Fortran" ierr = ierr + 1 else if (outname .ne. name .and. outname .ne. name2) then print *, " For datatype ", name, " found name ", * outname(1:rlen) ierr = ierr + 1 endif endif return end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/hindex1f.f000644 001750 001750 00000003146 12342443662 023256 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C C (C) 2011 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer errs, ierr, intsize integer i, displs(10), counts(10), dtype integer bufsize parameter (bufsize=100) integer inbuf(bufsize), outbuf(bufsize), packbuf(bufsize) integer position, len, psize C C Test for hindexed; C errs = 0 call mtest_init( ierr ) call mpi_type_size( MPI_INTEGER, intsize, ierr ) do i=1, 10 displs(i) = (10-i)*intsize counts(i) = 1 enddo call mpi_type_hindexed( 10, counts, displs, MPI_INTEGER, dtype, & ierr ) call mpi_type_commit( dtype, ierr ) C call mpi_pack_size( 1, dtype, MPI_COMM_WORLD, psize, ierr ) if (psize .gt. bufsize*intsize) then errs = errs + 1 else do i=1,10 inbuf(i) = i outbuf(i) = -i enddo position = 0 call mpi_pack( inbuf, 1, dtype, packbuf, psize, position, $ MPI_COMM_WORLD, ierr ) C len = position position = 0 call mpi_unpack( packbuf, len, position, outbuf, 10, $ MPI_INTEGER, MPI_COMM_WORLD, ierr ) C do i=1, 10 if (outbuf(i) .ne. 11-i) then errs = errs + 1 print *, 'outbuf(',i,')=',outbuf(i),', expected ', 10-i endif enddo endif C call mpi_type_free( dtype, ierr ) C call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/typeaints.h.in000644 001750 001750 00000000257 12342443662 024177 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C integer*@MPI_ADDRESS_SIZE@ aint, aintv(max_asizev) SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/typesnamef.f000644 001750 001750 00000003423 12342443662 023721 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' character*(MPI_MAX_OBJECT_NAME) cname integer rlen, ln integer ntype1, ntype2, errs, ierr errs = 0 call MTest_Init( ierr ) call mpi_type_vector( 10, 1, 100, MPI_INTEGER, ntype1, ierr ) rlen = -1 cname = 'XXXXXX' call mpi_type_get_name( ntype1, cname, rlen, ierr ) if (rlen .ne. 0) then errs = errs + 1 print *, ' Expected length 0, got ', rlen endif rlen = 0 do ln=MPI_MAX_OBJECT_NAME,1,-1 if (cname(ln:ln) .ne. ' ') then rlen = ln goto 100 endif enddo 100 continue if (rlen .ne. 0) then errs = errs + 1 print *, 'Datatype name is not all blank' endif C C now add a name, then dup call mpi_type_set_name( ntype1, 'a vector type', ierr ) call mpi_type_dup( ntype1, ntype2, ierr ) rlen = -1 cname = 'XXXXXX' call mpi_type_get_name( ntype2, cname, rlen, ierr ) if (rlen .ne. 0) then errs = errs + 1 print *, ' (type2) Expected length 0, got ', rlen endif rlen = 0 do ln=MPI_MAX_OBJECT_NAME,1,-1 if (cname(ln:ln) .ne. ' ') then rlen = ln goto 110 endif enddo 110 continue if (rlen .ne. 0) then errs = errs + 1 print *, ' (type2) Datatype name is not all blank' endif call mpi_type_free( ntype1, ierr ) call mpi_type_free( ntype2, ierr ) call MTest_Finalize( errs ) call MPI_Finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/typename3f.f000644 001750 001750 00000002237 12342443662 023623 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C C (C) 2012 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' character*(MPI_MAX_OBJECT_NAME) name integer namelen integer ierr, errs errs = 0 call mtest_init( ierr ) C C Check each Fortran datatype, including the size-specific ones C See the C version (typename.c) for the relevant MPI sections call MPI_Type_get_name( MPI_AINT, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_AINT") then errs = errs + 1 print *, "Expected MPI_AINT but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_OFFSET, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_OFFSET") then errs = errs + 1 print *, "Expected MPI_OFFSET but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_COUNT, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_COUNT") then errs = errs + 1 print *, "Expected MPI_COUNT but got "//name(1:namelen) endif call mtest_finalize( errs ) call MPI_Finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/typecntsf.f000644 001750 001750 00000006464 12342443662 023575 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer errs, ierr integer ntype1, ntype2 C C This is a very simple test that just tests that the contents/envelope C routines can be called. This should be upgraded to test the new C MPI-2 datatype routines (which use address-sized integers) C errs = 0 call mtest_init( ierr ) call explore( MPI_INTEGER, MPI_COMBINER_NAMED, errs ) call explore( MPI_BYTE, MPI_COMBINER_NAMED, errs ) call mpi_type_vector( 10, 1, 30, MPI_DOUBLE_PRECISION, ntype1, & ierr ) call explore( ntype1, MPI_COMBINER_VECTOR, errs ) call mpi_type_dup( ntype1, ntype2, ierr ) call explore( ntype2, MPI_COMBINER_DUP, errs ) call mpi_type_free( ntype2, ierr ) call mpi_type_free( ntype1, ierr ) C call mtest_finalize( errs ) call mpi_finalize( ierr ) end C subroutine explore( dtype, mycomb, errs ) implicit none include 'mpif.h' integer dtype, mycomb, errs integer ierr integer nints, nadds, ntype, combiner integer max_nints, max_dtypes, max_asizev parameter (max_nints = 10, max_dtypes = 10, max_asizev=10) integer intv(max_nints), dtypesv(max_dtypes) include 'typeaints.h' C call mpi_type_get_envelope( dtype, nints, nadds, ntype, & combiner, ierr ) C if (combiner .ne. MPI_COMBINER_NAMED) then call mpi_type_get_contents( dtype, & max_nints, max_asizev, max_dtypes, & intv, aintv, dtypesv, ierr ) C C dtypesv of constructed types must be free'd now C if (combiner .eq. MPI_COMBINER_DUP) then call mpi_type_free( dtypesv(1), ierr ) endif endif if (combiner .ne. mycomb) then errs = errs + 1 print *, ' Expected combiner ', mycomb, ' but got ', & combiner endif C C List all combiner types to check that they are defined in mpif.h if (combiner .eq. MPI_COMBINER_NAMED) then else if (combiner .eq. MPI_COMBINER_DUP) then else if (combiner .eq. MPI_COMBINER_CONTIGUOUS) then else if (combiner .eq. MPI_COMBINER_VECTOR) then else if (combiner .eq. MPI_COMBINER_HVECTOR_INTEGER) then else if (combiner .eq. MPI_COMBINER_HVECTOR) then else if (combiner .eq. MPI_COMBINER_INDEXED) then else if (combiner .eq. MPI_COMBINER_HINDEXED_INTEGER) then else if (combiner .eq. MPI_COMBINER_HINDEXED) then else if (combiner .eq. MPI_COMBINER_INDEXED_BLOCK) then else if (combiner .eq. MPI_COMBINER_STRUCT_INTEGER) then else if (combiner .eq. MPI_COMBINER_STRUCT) then else if (combiner .eq. MPI_COMBINER_SUBARRAY) then else if (combiner .eq. MPI_COMBINER_DARRAY) then else if (combiner .eq. MPI_COMBINER_F90_REAL) then else if (combiner .eq. MPI_COMBINER_F90_COMPLEX) then else if (combiner .eq. MPI_COMBINER_F90_INTEGER) then else if (combiner .eq. MPI_COMBINER_RESIZED) then else errs = errs + 1 print *, ' Unknown combiner ', combiner endif return end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/typem2f.f000644 001750 001750 00000012670 12342443662 023140 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer errs, ierr, i, intsize integer type1, type2, type3, type4, type5 integer max_asizev parameter (max_asizev = 10) include 'typeaints.h' integer blocklens(max_asizev), dtypes(max_asizev) integer displs(max_asizev) integer recvbuf(6*max_asizev) integer sendbuf(max_asizev), status(MPI_STATUS_SIZE) integer rank, size errs = 0 call mtest_init( ierr ) call mpi_comm_size( MPI_COMM_WORLD, size, ierr ) call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) C call mpi_type_size( MPI_INTEGER, intsize, ierr ) C aintv(1) = 0 aintv(2) = 3 * intsize call mpi_type_create_resized( MPI_INTEGER, aintv(1), aintv(2), & type1, ierr ) call mpi_type_commit( type1, ierr ) aintv(1) = -1 aintv(2) = -1 call mpi_type_get_extent( type1, aintv(1), aintv(2), ierr ) if (aintv(1) .ne. 0) then errs = errs + 1 print *, 'Did not get expected lb' endif if (aintv(2) .ne. 3*intsize) then errs = errs + 1 print *, 'Did not get expected extent' endif aintv(1) = -1 aintv(2) = -1 call mpi_type_get_true_extent( type1, aintv(1), aintv(2), ierr ) if (aintv(1) .ne. 0) then errs = errs + 1 print *, 'Did not get expected true lb' endif if (aintv(2) .ne. intsize) then errs = errs + 1 print *, 'Did not get expected true extent (', aintv(2), ') ', & ' expected ', intsize endif C do i=1,10 blocklens(i) = 1 aintv(i) = (i-1) * 3 * intsize enddo call mpi_type_create_hindexed( 10, blocklens, aintv, & MPI_INTEGER, type2, ierr ) call mpi_type_commit( type2, ierr ) C aint = 3 * intsize call mpi_type_create_hvector( 10, 1, aint, MPI_INTEGER, type3, & ierr ) call mpi_type_commit( type3, ierr ) C do i=1,10 blocklens(i) = 1 dtypes(i) = MPI_INTEGER aintv(i) = (i-1) * 3 * intsize enddo call mpi_type_create_struct( 10, blocklens, aintv, dtypes, & type4, ierr ) call mpi_type_commit( type4, ierr ) do i=1,10 displs(i) = (i-1) * 3 enddo call mpi_type_create_indexed_block( 10, 1, displs, & MPI_INTEGER, type5, ierr ) call mpi_type_commit( type5, ierr ) C C Using each time, send and receive using these types do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & recvbuf, max_asizev, type1, rank, 0, & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type1:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo C do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & recvbuf, 1, type2, rank, 0, & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type2:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo C do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & recvbuf, 1, type3, rank, 0, & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type3:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo C do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & recvbuf, 1, type4, rank, 0, & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type4:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo C do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & recvbuf, 1, type5, rank, 0, & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type5:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo C call mpi_type_free( type1, ierr ) call mpi_type_free( type2, ierr ) call mpi_type_free( type3, ierr ) call mpi_type_free( type4, ierr ) call mpi_type_free( type5, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/datatype/CMakeLists.txt000644 001750 001750 00000004722 12342443654 024143 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite AND SMPI_F2C) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include/") configure_file(${CMAKE_CURRENT_SOURCE_DIR}/typeaints.h.in ${CMAKE_CURRENT_SOURCE_DIR}/typeaints.h @ONLY) # add_executable(allctypesf allctypesf.f) add_executable(gaddressf gaddressf.f) # add_executable(hindex1f hindex1f.f) # add_executable(hindexed_blockf hindexed_blockf.f) # add_executable(packef packef.f) # add_executable(typecntsf typecntsf.f) # add_executable(typem2f typem2f.f) # add_executable(typename3f typename3f.f) # add_executable(typenamef typenamef.f) # add_executable(typesnamef typesnamef.f) # add_executable(typesubf typesubf.f) # target_link_libraries(allctypesf simgrid mtest_f77) target_link_libraries(gaddressf simgrid mtest_f77) # target_link_libraries(hindex1f simgrid mtest_f77) # target_link_libraries(hindexed_blockf simgrid mtest_f77) # target_link_libraries(packef simgrid mtest_f77) # target_link_libraries(typecntsf simgrid mtest_f77) # target_link_libraries(typem2f simgrid mtest_f77) # target_link_libraries(typename3f simgrid mtest_f77) # target_link_libraries(typenamef simgrid mtest_f77) # target_link_libraries(typesnamef simgrid mtest_f77) # target_link_libraries(typesubf simgrid mtest_f77) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/allctypesf.f ${CMAKE_CURRENT_SOURCE_DIR}/gaddressf.f ${CMAKE_CURRENT_SOURCE_DIR}/hindex1f.f ${CMAKE_CURRENT_SOURCE_DIR}/hindexed_blockf.f ${CMAKE_CURRENT_SOURCE_DIR}/packef.f ${CMAKE_CURRENT_SOURCE_DIR}/typeaints.h.in ${CMAKE_CURRENT_SOURCE_DIR}/typecntsf.f ${CMAKE_CURRENT_SOURCE_DIR}/typem2f.f ${CMAKE_CURRENT_SOURCE_DIR}/typename3f.f ${CMAKE_CURRENT_SOURCE_DIR}/typenamef.f ${CMAKE_CURRENT_SOURCE_DIR}/typesnamef.f ${CMAKE_CURRENT_SOURCE_DIR}/typesubf.f PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/000755 001750 001750 00000000000 12342443666 020517 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/alltoallvf.f000644 001750 001750 00000011036 12342443662 023023 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2011 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer ierr, errs integer i, ans, size, rank, color, comm, newcomm integer maxSize, displ parameter (maxSize=128) integer scounts(maxSize), sdispls(maxSize), stypes(maxSize) integer rcounts(maxSize), rdispls(maxSize), rtypes(maxSize) integer sbuf(maxSize), rbuf(maxSize) errs = 0 call mtest_init( ierr ) C Get a comm call mpi_comm_dup( MPI_COMM_WORLD, comm, ierr ) call mpi_comm_size( comm, size, ierr ) if (size .gt. maxSize) then call mpi_comm_rank( comm, rank, ierr ) color = 1 if (rank .lt. maxSize) color = 0 call mpi_comm_split( comm, color, rank, newcomm, ierr ) call mpi_comm_free( comm, ierr ) comm = newcomm call mpi_comm_size( comm, size, ierr ) endif call mpi_comm_rank( comm, rank, ierr ) C if (size .le. maxSize) then C Initialize the data. Just use this as an all to all C Use the same test as alltoallwf.c , except displacements are in units of C integers instead of bytes do i=1, size scounts(i) = 1 sdispls(i) = (i-1) stypes(i) = MPI_INTEGER sbuf(i) = rank * size + i rcounts(i) = 1 rdispls(i) = (i-1) rtypes(i) = MPI_INTEGER rbuf(i) = -1 enddo call mpi_alltoallv( sbuf, scounts, sdispls, stypes, & rbuf, rcounts, rdispls, rtypes, comm, ierr ) C C check rbuf(i) = data from the ith location of the ith send buf, or C rbuf(i) = (i-1) * size + i do i=1, size ans = (i-1) * size + rank + 1 if (rbuf(i) .ne. ans) then errs = errs + 1 print *, rank, ' rbuf(', i, ') = ', rbuf(i), & ' expected ', ans endif enddo C C A halo-exchange example - mostly zero counts C do i=1, size scounts(i) = 0 sdispls(i) = 0 stypes(i) = MPI_INTEGER sbuf(i) = -1 rcounts(i) = 0 rdispls(i) = 0 rtypes(i) = MPI_INTEGER rbuf(i) = -1 enddo C C Note that the arrays are 1-origin displ = 0 if (rank .gt. 0) then scounts(1+rank-1) = 1 rcounts(1+rank-1) = 1 sdispls(1+rank-1) = displ rdispls(1+rank-1) = rank - 1 sbuf(1+displ) = rank displ = displ + 1 endif scounts(1+rank) = 1 rcounts(1+rank) = 1 sdispls(1+rank) = displ rdispls(1+rank) = rank sbuf(1+displ) = rank displ = displ + 1 if (rank .lt. size-1) then scounts(1+rank+1) = 1 rcounts(1+rank+1) = 1 sdispls(1+rank+1) = displ rdispls(1+rank+1) = rank+1 sbuf(1+displ) = rank displ = displ + 1 endif call mpi_alltoallv( sbuf, scounts, sdispls, stypes, & rbuf, rcounts, rdispls, rtypes, comm, ierr ) C C Check the neighbor values are correctly moved C if (rank .gt. 0) then if (rbuf(1+rank-1) .ne. rank-1) then errs = errs + 1 print *, rank, ' rbuf(',1+rank-1, ') = ', rbuf(1+rank-1), & 'expected ', rank-1 endif endif if (rbuf(1+rank) .ne. rank) then errs = errs + 1 print *, rank, ' rbuf(', 1+rank, ') = ', rbuf(1+rank), & 'expected ', rank endif if (rank .lt. size-1) then if (rbuf(1+rank+1) .ne. rank+1) then errs = errs + 1 print *, rank, ' rbuf(', 1+rank+1, ') = ',rbuf(1+rank+1), & 'expected ', rank+1 endif endif do i=0,rank-2 if (rbuf(1+i) .ne. -1) then errs = errs + 1 print *, rank, ' rbuf(', 1+i, ') = ', rbuf(1+i), & 'expected -1' endif enddo do i=rank+2,size-1 if (rbuf(1+i) .ne. -1) then errs = errs + 1 print *, rank, ' rbuf(', i, ') = ', rbuf(1+i), & 'expected -1' endif enddo endif call mpi_comm_free( comm, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/split_typef.f000644 001750 001750 00000002472 12342443662 023231 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2011 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer ierr, errs integer i, ans, size, rank, color, comm, newcomm integer maxSize, displ parameter (maxSize=128) integer scounts(maxSize), sdispls(maxSize), stypes(maxSize) integer rcounts(maxSize), rdispls(maxSize), rtypes(maxSize) integer sbuf(maxSize), rbuf(maxSize) errs = 0 call mtest_init( ierr ) call mpi_comm_dup( MPI_COMM_WORLD, comm, ierr ) call mpi_comm_split_type( comm, MPI_COMM_TYPE_SHARED, rank, & MPI_INFO_NULL, newcomm, ierr ) call mpi_comm_rank( newcomm, rank, ierr ) call mpi_comm_size( newcomm, size, ierr ) do i=1, size scounts(i) = 1 sdispls(i) = (i-1) stypes(i) = MPI_INTEGER sbuf(i) = rank * size + i rcounts(i) = 1 rdispls(i) = (i-1) rtypes(i) = MPI_INTEGER rbuf(i) = -1 enddo call mpi_alltoallv( sbuf, scounts, sdispls, stypes, & rbuf, rcounts, rdispls, rtypes, newcomm, ierr ) call mpi_comm_free( newcomm, ierr ) call mpi_comm_free( comm, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/allredopttf.f000644 001750 001750 00000002612 12342443662 023203 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2007 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer*8 inbuf, outbuf double complex zinbuf, zoutbuf integer wsize integer errs, ierr errs = 0 call mtest_init( ierr ) call mpi_comm_size( MPI_COMM_WORLD, wsize, ierr ) C C A simple test of allreduce for the optional integer*8 type inbuf = 1 outbuf = 0 call mpi_allreduce(inbuf, outbuf, 1, MPI_INTEGER8, MPI_SUM, & MPI_COMM_WORLD, ierr) if (outbuf .ne. wsize ) then errs = errs + 1 print *, "result wrong for sum with integer*8 = got ", outbuf, & " but should have ", wsize endif zinbuf = (1,1) zoutbuf = (0,0) call mpi_allreduce(zinbuf, zoutbuf, 1, MPI_DOUBLE_COMPLEX, & MPI_SUM, MPI_COMM_WORLD, ierr) if (dreal(zoutbuf) .ne. wsize ) then errs = errs + 1 print *, "result wrong for sum with double complex = got ", & outbuf, " but should have ", wsize endif if (dimag(zoutbuf) .ne. wsize ) then errs = errs + 1 print *, "result wrong for sum with double complex = got ", & outbuf, " but should have ", wsize endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/testlist000644 001750 001750 00000000402 12342443666 022311 0ustar00cici000000 000000 uallreducef 4 exscanf 5 #alltoallwf 7 alltoallvf 7 inplacef 4 reducelocalf 2 mpiversion=2.2 redscatf 4 split_typef 4 mpiversion=3.0 nonblockingf 4 mpiversion=3.0 vw_inplacef 4 mpiversion=2.2 red_scat_blockf 4 mpiversion=2.2 nonblocking_inpf 4 mpiversion=3.0 SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/uallreducef.f000644 001750 001750 00000003113 12342443662 023153 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C C C Test user-defined operations. This tests a simple commutative operation C subroutine uop( cin, cout, count, datatype ) implicit none include 'mpif.h' integer cin(*), cout(*) integer count, datatype integer i C if (datatype .ne. MPI_INTEGER) then C print *, 'Invalid datatype (',datatype,') passed to user_op()' C return C endif do i=1, count cout(i) = cin(i) + cout(i) enddo end program main implicit none include 'mpif.h' external uop integer ierr, errs integer count, sumop, vin(65000), vout(65000), i, size integer comm errs = 0 call mtest_init(ierr) call mpi_op_create( uop, .true., sumop, ierr ) comm = MPI_COMM_WORLD call mpi_comm_size( comm, size, ierr ) count = 1 do while (count .lt. 65000) do i=1, count vin(i) = i vout(i) = -1 enddo call mpi_allreduce( vin, vout, count, MPI_INTEGER, sumop, * comm, ierr ) C Check that all results are correct do i=1, count if (vout(i) .ne. i * size) then errs = errs + 1 if (errs .lt. 10) print *, "vout(",i,") = ", vout(i) endif enddo count = count + count enddo call mpi_op_free( sumop, ierr ) call mtest_finalize(errs) call mpi_finalize(ierr) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/nonblocking_inpf.f000644 001750 001750 00000010150 12342443662 024176 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2012 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C C A simple test for Fortran support of the MPI_IN_PLACE value in Alltoall[vw]. C program main implicit none include 'mpif.h' integer SIZEOFINT integer MAX_SIZE parameter (MAX_SIZE=1024) integer rbuf(MAX_SIZE) integer rdispls(MAX_SIZE), rcounts(MAX_SIZE), rtypes(MAX_SIZE) integer comm, rank, size, req integer sumval, ierr, errs integer iexpected, igot integer i, j errs = 0 call mtest_init( ierr ) comm = MPI_COMM_WORLD call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) call mpi_type_size( MPI_INTEGER, SIZEOFINT, ierr ) do i=1,MAX_SIZE rbuf(i) = -1 enddo do i=1,size rbuf(i) = (i-1) * size + rank enddo call mpi_ialltoall( MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, . rbuf, 1, MPI_INTEGER, comm, req, ierr ) call mpi_wait( req, MPI_STATUS_IGNORE, ierr ) do i=1,size if (rbuf(i) .ne. (rank*size + i - 1)) then errs = errs + 1 print *, '[', rank, ']: IALLTOALL rbuf(', i, ') = ', . rbuf(i), ', should be', rank * size + i - 1 endif enddo do i=1,MAX_SIZE rbuf(i) = -1 enddo do i=1,size rcounts(i) = i-1 + rank rdispls(i) = (i-1) * (2*size) do j=0,rcounts(i)-1 rbuf(rdispls(i)+j+1) = 100 * rank + 10 * (i-1) + j enddo enddo call mpi_ialltoallv( MPI_IN_PLACE, 0, 0, MPI_DATATYPE_NULL, . rbuf, rcounts, rdispls, MPI_INTEGER, . comm, req, ierr ) call mpi_wait( req, MPI_STATUS_IGNORE, ierr ) do i=1,size do j=0,rcounts(i)-1 iexpected = 100 * (i-1) + 10 * rank + j igot = rbuf(rdispls(i)+j+1) if ( igot .ne. iexpected ) then errs = errs + 1 print *, '[', rank, ']: IALLTOALLV got ', igot, . ',but expected ', iexpected, . ' for block=', i-1, ' element=', j endif enddo enddo do i=1,MAX_SIZE rbuf(i) = -1 enddo do i=1,size rcounts(i) = i-1 + rank rdispls(i) = (i-1) * (2*size) * SIZEOFINT rtypes(i) = MPI_INTEGER do j=0,rcounts(i)-1 rbuf(rdispls(i)/SIZEOFINT+j+1) = 100 * rank . + 10 * (i-1) + j enddo enddo call mpi_ialltoallw( MPI_IN_PLACE, 0, 0, MPI_DATATYPE_NULL, . rbuf, rcounts, rdispls, rtypes, . comm, req, ierr ) call mpi_wait( req, MPI_STATUS_IGNORE, ierr ) do i=1,size do j=0,rcounts(i)-1 iexpected = 100 * (i-1) + 10 * rank + j igot = rbuf(rdispls(i)/SIZEOFINT+j+1) if ( igot .ne. iexpected ) then errs = errs + 1 print *, '[', rank, ']: IALLTOALLW got ', igot, . ',but expected ', iexpected, . ' for block=', i-1, ' element=', j endif enddo enddo do i=1,MAX_SIZE rbuf(i) = -1 enddo do i = 1, size rbuf(i) = rank + (i-1) enddo call mpi_ireduce_scatter_block( MPI_IN_PLACE, rbuf, 1, . MPI_INTEGER, MPI_SUM, comm, . req, ierr ) call mpi_wait( req, MPI_STATUS_IGNORE, ierr ) sumval = size * rank + ((size-1) * size)/2 if ( rbuf(1) .ne. sumval ) then errs = errs + 1 print *, 'Ireduce_scatter_block does not get expected value.' print *, '[', rank, ']:', 'Got ', rbuf(1), ' but expected ', . sumval, '.' endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/nonblockingf.f000644 001750 001750 00000006455 12342443662 023345 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2012 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer NUM_INTS parameter (NUM_INTS=2) integer maxSize parameter (maxSize=128) integer scounts(maxSize), sdispls(maxSize) integer rcounts(maxSize), rdispls(maxSize) integer types(maxSize) integer sbuf(maxSize), rbuf(maxSize) integer comm, size, rank, req integer ierr, errs integer ii, ans errs = 0 call mtest_init(ierr) comm = MPI_COMM_WORLD call MPI_Comm_size(comm, size, ierr) call MPI_Comm_rank(comm, rank, ierr) C do ii = 1, size sbuf(2*ii-1) = ii sbuf(2*ii) = ii sbuf(2*ii-1) = ii sbuf(2*ii) = ii scounts(ii) = NUM_INTS rcounts(ii) = NUM_INTS sdispls(ii) = (ii-1) * NUM_INTS rdispls(ii) = (ii-1) * NUM_INTS types(ii) = MPI_INTEGER enddo call MPI_Ibarrier(comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ibcast(sbuf, NUM_INTS, MPI_INTEGER, 0, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Igather(sbuf, NUM_INTS, MPI_INTEGER, . rbuf, NUM_INTS, MPI_INTEGER, . 0, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Igatherv(sbuf, NUM_INTS, MPI_INTEGER, . rbuf, rcounts, rdispls, MPI_INTEGER, . 0, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ialltoall(sbuf, NUM_INTS, MPI_INTEGER, . rbuf, NUM_INTS, MPI_INTEGER, . comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ialltoallv(sbuf, scounts, sdispls, MPI_INTEGER, . rbuf, rcounts, rdispls, MPI_INTEGER, . comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ialltoallw(sbuf, scounts, sdispls, types, . rbuf, rcounts, rdispls, types, . comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ireduce(sbuf, rbuf, NUM_INTS, MPI_INTEGER, . MPI_SUM, 0, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Iallreduce(sbuf, rbuf, NUM_INTS, MPI_INTEGER, . MPI_SUM, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ireduce_scatter(sbuf, rbuf, rcounts, MPI_INTEGER, . MPI_SUM, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ireduce_scatter_block(sbuf, rbuf, NUM_INTS, MPI_INTEGER, . MPI_SUM, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Iscan(sbuf, rbuf, NUM_INTS, MPI_INTEGER, . MPI_SUM, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Iexscan(sbuf, rbuf, NUM_INTS, MPI_INTEGER, . MPI_SUM, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call mtest_finalize( errs ) call MPI_Finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/allredint8f.f000644 001750 001750 00000001046 12342443662 023077 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2006 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer*8 inbuf, outbuf integer errs, ierr errs = 0 call mtest_init( ierr ) C C A simple test of allreduce for the optional integer*8 type call mpi_allreduce(inbuf, outbuf, 1, MPI_INTEGER8, MPI_SUM, & MPI_COMM_WORLD, ierr) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/redscatf.f000644 001750 001750 00000004433 12342443662 022461 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2011 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C subroutine uop( cin, cout, count, datatype ) implicit none include 'mpif.h' integer cin(*), cout(*) integer count, datatype integer i if (.false.) then if (datatype .ne. MPI_INTEGER) then write(6,*) 'Invalid datatype ',datatype, & ' passed to user_op()' return endif endif do i=1, count cout(i) = cin(i) + cout(i) enddo end C C Test of reduce scatter. C C Each processor contributes its rank + the index to the reduction, C then receives the ith sum C C Can be called with any number of processors. C program main implicit none include 'mpif.h' integer errs, ierr, toterr integer maxsize parameter (maxsize=1024) integer sendbuf(maxsize), recvbuf, recvcounts(maxsize) integer size, rank, i, sumval integer comm, sumop external uop errs = 0 call mtest_init( ierr ) comm = MPI_COMM_WORLD call mpi_comm_size( comm, size, ierr ) call mpi_comm_rank( comm, rank, ierr ) if (size .gt. maxsize) then endif do i=1, size sendbuf(i) = rank + i - 1 recvcounts(i) = 1 enddo call mpi_reduce_scatter( sendbuf, recvbuf, recvcounts, & MPI_INTEGER, MPI_SUM, comm, ierr ) sumval = size * rank + ((size - 1) * size)/2 C recvbuf should be size * (rank + i) if (recvbuf .ne. sumval) then errs = errs + 1 print *, "Did not get expected value for reduce scatter" print *, rank, " Got ", recvbuf, " expected ", sumval endif call mpi_op_create( uop, .true., sumop, ierr ) call mpi_reduce_scatter( sendbuf, recvbuf, recvcounts, & MPI_INTEGER, sumop, comm, ierr ) sumval = size * rank + ((size - 1) * size)/2 C recvbuf should be size * (rank + i) if (recvbuf .ne. sumval) then errs = errs + 1 print *, "sumop: Did not get expected value for reduce scatter" print *, rank, " Got ", recvbuf, " expected ", sumval endif call mpi_op_free( sumop, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/reducelocalf.f000644 001750 001750 00000004557 12342443662 023325 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2009 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C C C Test Fortran MPI_Reduce_local with MPI_OP_SUM and with user-defined operation. C subroutine user_op( invec, outvec, count, datatype ) implicit none include 'mpif.h' integer invec(*), outvec(*) integer count, datatype integer ii if (datatype .ne. MPI_INTEGER) then write(6,*) 'Invalid datatype passed to user_op()' return endif do ii=1, count outvec(ii) = invec(ii) * 2 + outvec(ii) enddo end program main implicit none include 'mpif.h' integer max_buf_size parameter (max_buf_size=65000) integer vin(max_buf_size), vout(max_buf_size) external user_op integer ierr, errs integer count, myop integer ii errs = 0 call mtest_init(ierr) count = 0 do while (count .le. max_buf_size ) do ii = 1,count vin(ii) = ii vout(ii) = ii enddo call mpi_reduce_local( vin, vout, count, & MPI_INTEGER, MPI_SUM, ierr ) C Check if the result is correct do ii = 1,count if ( vin(ii) .ne. ii ) then errs = errs + 1 endif if ( vout(ii) .ne. 2*ii ) then errs = errs + 1 endif enddo if ( count .gt. 0 ) then count = count + count else count = 1 endif enddo call mpi_op_create( user_op, .false., myop, ierr ) count = 0 do while (count .le. max_buf_size) do ii = 1, count vin(ii) = ii vout(ii) = ii enddo call mpi_reduce_local( vin, vout, count, & MPI_INTEGER, myop, ierr ) C Check if the result is correct do ii = 1, count if ( vin(ii) .ne. ii ) then errs = errs + 1 endif if ( vout(ii) .ne. 3*ii ) then errs = errs + 1 endif enddo if ( count .gt. 0 ) then count = count + count else count = 1 endif enddo call mpi_op_free( myop, ierr ) call mtest_finalize(errs) call mpi_finalize(ierr) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/inplacef.f000644 001750 001750 00000005115 12342443662 022445 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2005 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C C This is a simple test that Fortran support the MPI_IN_PLACE value C program main implicit none include 'mpif.h' integer ierr, errs integer comm, root integer rank, size integer i integer MAX_SIZE parameter (MAX_SIZE=1024) integer rbuf(MAX_SIZE), rdispls(MAX_SIZE), rcount(MAX_SIZE), $ sbuf(MAX_SIZE) errs = 0 call mtest_init( ierr ) comm = MPI_COMM_WORLD call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) root = 0 C Gather with inplace do i=1,size rbuf(i) = - i enddo rbuf(1+root) = root if (rank .eq. root) then call mpi_gather( MPI_IN_PLACE, 1, MPI_INTEGER, rbuf, 1, $ MPI_INTEGER, root, comm, ierr ) do i=1,size if (rbuf(i) .ne. i-1) then errs = errs + 1 print *, '[',rank,'] rbuf(', i, ') = ', rbuf(i), $ ' in gather' endif enddo else call mpi_gather( rank, 1, MPI_INTEGER, rbuf, 1, MPI_INTEGER, $ root, comm, ierr ) endif C Gatherv with inplace do i=1,size rbuf(i) = - i rcount(i) = 1 rdispls(i) = i-1 enddo rbuf(1+root) = root if (rank .eq. root) then call mpi_gatherv( MPI_IN_PLACE, 1, MPI_INTEGER, rbuf, rcount, $ rdispls, MPI_INTEGER, root, comm, ierr ) do i=1,size if (rbuf(i) .ne. i-1) then errs = errs + 1 print *, '[', rank, '] rbuf(', i, ') = ', rbuf(i), $ ' in gatherv' endif enddo else call mpi_gatherv( rank, 1, MPI_INTEGER, rbuf, rcount, rdispls, $ MPI_INTEGER, root, comm, ierr ) endif C Scatter with inplace do i=1,size sbuf(i) = i enddo rbuf(1) = -1 if (rank .eq. root) then call mpi_scatter( sbuf, 1, MPI_INTEGER, MPI_IN_PLACE, 1, $ MPI_INTEGER, root, comm, ierr ) else call mpi_scatter( sbuf, 1, MPI_INTEGER, rbuf, 1, $ MPI_INTEGER, root, comm, ierr ) if (rbuf(1) .ne. rank+1) then errs = errs + 1 print *, '[', rank, '] rbuf = ', rbuf(1), $ ' in scatter' endif endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/alltoallwf.f000644 001750 001750 00000004126 12342443662 023026 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer ierr, errs integer i, intsize, ans, size, rank, color, comm, newcomm integer maxSize parameter (maxSize=32) integer scounts(maxSize), sdispls(maxSize), stypes(maxSize) integer rcounts(maxSize), rdispls(maxSize), rtypes(maxSize) integer sbuf(maxSize), rbuf(maxSize) errs = 0 call mtest_init( ierr ) call mpi_type_size( MPI_INTEGER, intsize, ierr ) C Get a comm call mpi_comm_dup( MPI_COMM_WORLD, comm, ierr ) call mpi_comm_size( comm, size, ierr ) if (size .gt. maxSize) then call mpi_comm_rank( comm, rank, ierr ) color = 1 if (rank .lt. maxSize) color = 0 call mpi_comm_split( comm, color, rank, newcomm, ierr ) call mpi_comm_free( comm, ierr ) comm = newcomm call mpi_comm_size( comm, size, ierr ) endif call mpi_comm_rank( comm, rank, ierr ) if (size .le. maxSize) then C Initialize the data. Just use this as an all to all do i=1, size scounts(i) = 1 sdispls(i) = (i-1)*intsize stypes(i) = MPI_INTEGER sbuf(i) = rank * size + i rcounts(i) = 1 rdispls(i) = (i-1)*intsize rtypes(i) = MPI_INTEGER rbuf(i) = -1 enddo call mpi_alltoallw( sbuf, scounts, sdispls, stypes, & rbuf, rcounts, rdispls, rtypes, comm, ierr ) C C check rbuf(i) = data from the ith location of the ith send buf, or C rbuf(i) = (i-1) * size + i do i=1, size ans = (i-1) * size + rank + 1 if (rbuf(i) .ne. ans) then errs = errs + 1 print *, rank, ' rbuf(', i, ') = ', rbuf(i), & ' expected ', ans endif enddo endif call mpi_comm_free( comm, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/exscanf.f000644 001750 001750 00000006116 12342443662 022315 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C subroutine uop( cin, cout, count, datatype ) implicit none include 'mpif.h' integer cin(*), cout(*) integer count, datatype integer i if (.false.) then if (datatype .ne. MPI_INTEGER) then write(6,*) 'Invalid datatype passed to user_op()' return endif endif do i=1, count cout(i) = cin(i) + cout(i) enddo end C program main implicit none include 'mpif.h' integer inbuf(2), outbuf(2) integer ans, rank, size, comm integer errs, ierr integer sumop external uop errs = 0 call mtest_init( ierr ) C C A simple test of exscan comm = MPI_COMM_WORLD call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) inbuf(1) = rank inbuf(2) = -rank call mpi_exscan( inbuf, outbuf, 2, MPI_INTEGER, MPI_SUM, comm, & ierr ) C this process has the sum of i from 0 to rank-1, which is C (rank)(rank-1)/2 and -i ans = (rank * (rank - 1))/2 if (rank .gt. 0) then if (outbuf(1) .ne. ans) then errs = errs + 1 print *, rank, ' Expected ', ans, ' got ', outbuf(1) endif if (outbuf(2) .ne. -ans) then errs = errs + 1 print *, rank, ' Expected ', -ans, ' got ', outbuf(1) endif endif C C Try a user-defined operation C call mpi_op_create( uop, .true., sumop, ierr ) inbuf(1) = rank inbuf(2) = -rank call mpi_exscan( inbuf, outbuf, 2, MPI_INTEGER, sumop, comm, & ierr ) C this process has the sum of i from 0 to rank-1, which is C (rank)(rank-1)/2 and -i ans = (rank * (rank - 1))/2 if (rank .gt. 0) then if (outbuf(1) .ne. ans) then errs = errs + 1 print *, rank, ' sumop: Expected ', ans, ' got ', outbuf(1) endif if (outbuf(2) .ne. -ans) then errs = errs + 1 print *, rank, ' sumop: Expected ', -ans, ' got ', outbuf(1) endif endif call mpi_op_free( sumop, ierr ) C C Try a user-defined operation (and don't claim it is commutative) C call mpi_op_create( uop, .false., sumop, ierr ) inbuf(1) = rank inbuf(2) = -rank call mpi_exscan( inbuf, outbuf, 2, MPI_INTEGER, sumop, comm, & ierr ) C this process has the sum of i from 0 to rank-1, which is C (rank)(rank-1)/2 and -i ans = (rank * (rank - 1))/2 if (rank .gt. 0) then if (outbuf(1) .ne. ans) then errs = errs + 1 print *, rank, ' sumop2: Expected ', ans, ' got ', outbuf(1) endif if (outbuf(2) .ne. -ans) then errs = errs + 1 print *, rank, ' sumop2: Expected ', -ans, ' got ',outbuf(1) endif endif call mpi_op_free( sumop, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/red_scat_blockf.f000644 001750 001750 00000003207 12342443662 023770 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2012 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C C A simple test for Fortran support of Reduce_scatter_block C with or withoutMPI_IN_PLACE. C program main implicit none include 'mpif.h' integer MAX_SIZE parameter (MAX_SIZE=1024) integer sbuf(MAX_SIZE), rbuf(MAX_SIZE) integer comm, rank, size integer sumval, ierr, errs, i errs = 0 call mtest_init( ierr ) comm = MPI_COMM_WORLD call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) do i = 1, size sbuf(i) = rank + (i-1) enddo call MPI_Reduce_scatter_block(sbuf, rbuf, 1, MPI_INTEGER, . MPI_SUM, comm, ierr) sumval = size * rank + ((size-1) * size)/2 if ( rbuf(1) .ne. sumval ) then errs = errs + 1 print *, 'Reduce_scatter_block does not get expected value.' print *, '[', rank, ']', 'Got ', rbuf(1), ' but expected ', . sumval, '.' endif C Try MPI_IN_PLACE do i = 1, size rbuf(i) = rank + (i-1) enddo call MPI_Reduce_scatter_block(MPI_IN_PLACE, rbuf, 1, MPI_INTEGER, . MPI_SUM, comm, ierr) if ( rbuf(1) .ne. sumval ) then errs = errs + 1 print *, 'Reduce_scatter_block does not get expected value.' print *, '[', rank, ']', 'Got ', rbuf(1), ' but expected ', . sumval, '.' endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/vw_inplacef.f000644 001750 001750 00000006743 12342443662 023171 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2012 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C C A simple test for Fortran support of the MPI_IN_PLACE value in Alltoall[vw]. C program main implicit none include 'mpif.h' integer SIZEOFINT integer MAX_SIZE parameter (MAX_SIZE=1024) integer rbuf(MAX_SIZE) integer rdispls(MAX_SIZE), rcounts(MAX_SIZE), rtypes(MAX_SIZE) integer ierr, errs integer comm, root integer rank, size integer iexpected, igot integer i, j errs = 0 call mtest_init( ierr ) comm = MPI_COMM_WORLD call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) call mpi_type_size( MPI_INTEGER, SIZEOFINT, ierr ) if (size .gt. MAX_SIZE) then print *, ' At most ', MAX_SIZE, ' processes allowed' call mpi_abort( MPI_COMM_WORLD, 1, ierr ) endif C do i=1,MAX_SIZE rbuf(i) = -1 enddo do i=1,size rbuf(i) = (i-1) * size + rank enddo call mpi_alltoall( MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, $ rbuf, 1, MPI_INTEGER, comm, ierr ) do i=1,size if (rbuf(i) .ne. (rank*size + i - 1)) then errs = errs + 1 print *, '[', rank, '] rbuf(', i, ') = ', rbuf(i), $ ', should be', rank * size + i - 1 endif enddo do i=1,MAX_SIZE rbuf(i) = -1 enddo do i=1,size rcounts(i) = (i-1) + rank rdispls(i) = (i-1) * (2*size) do j=0,rcounts(i)-1 rbuf(rdispls(i)+j+1) = 100 * rank + 10 * (i-1) + j enddo enddo call mpi_alltoallv( MPI_IN_PLACE, 0, 0, MPI_DATATYPE_NULL, $ rbuf, rcounts, rdispls, MPI_INTEGER, $ comm, ierr ) do i=1,size do j=0,rcounts(i)-1 iexpected = 100 * (i-1) + 10 * rank + j igot = rbuf(rdispls(i)+j+1) if ( igot .ne. iexpected ) then errs = errs + 1 print *, '[', rank, '] ALLTOALLV got ', igot, $ ',but expected ', iexpected, $ ' for block=', i-1, ' element=', j endif enddo enddo do i=1,MAX_SIZE rbuf(i) = -1 enddo C Alltoallw's displs[] are in bytes not in type extents. do i=1,size rcounts(i) = (i-1) + rank rdispls(i) = (i-1) * (2*size) * SIZEOFINT rtypes(i) = MPI_INTEGER do j=0,rcounts(i)-1 rbuf(rdispls(i)/SIZEOFINT+j+1) = 100 * rank $ + 10 * (i-1) + j enddo enddo call mpi_alltoallw( MPI_IN_PLACE, 0, 0, MPI_DATATYPE_NULL, $ rbuf, rcounts, rdispls, rtypes, $ comm, ierr ) do i=1,size do j=0,rcounts(i)-1 iexpected = 100 * (i-1) + 10 * rank + j igot = rbuf(rdispls(i)/SIZEOFINT+j+1) if ( igot .ne. iexpected ) then errs = errs + 1 print *, '[', rank, '] ALLTOALLW got ', igot, $ ',but expected ', iexpected, $ ' for block=', i-1, ' element=', j endif enddo enddo call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/coll/CMakeLists.txt000644 001750 001750 00000005450 12342443654 023260 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite AND SMPI_F2C) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include/") # add_executable(allredint8f allredint8f.f) # add_executable(allredopttf allredopttf.f) add_executable(alltoallvf alltoallvf.f) # add_executable(alltoallwf alltoallwf.f) add_executable(exscanf exscanf.f) add_executable(inplacef inplacef.f) # add_executable(nonblockingf nonblockingf.f) # add_executable(nonblocking_inpf nonblocking_inpf.f) add_executable(red_scat_blockf red_scat_blockf.f) add_executable(redscatf redscatf.f) add_executable(reducelocalf reducelocalf.f) add_executable(split_typef split_typef.f) add_executable(uallreducef uallreducef.f) add_executable(vw_inplacef vw_inplacef.f) # target_link_libraries(allredint8f simgrid mtest_f77) # target_link_libraries(allredopttf simgrid mtest_f77) target_link_libraries(alltoallvf simgrid mtest_f77) # target_link_libraries(alltoallwf simgrid mtest_f77) target_link_libraries(exscanf simgrid mtest_f77) target_link_libraries(inplacef simgrid mtest_f77) # target_link_libraries(nonblockingf simgrid mtest_f77) # target_link_libraries(nonblocking_inpf simgrid mtest_f77) target_link_libraries(red_scat_blockf simgrid mtest_f77) target_link_libraries(redscatf simgrid mtest_f77) target_link_libraries(reducelocalf simgrid mtest_f77) target_link_libraries(split_typef simgrid mtest_f77) target_link_libraries(uallreducef simgrid mtest_f77) target_link_libraries(vw_inplacef simgrid mtest_f77) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/allredint8f.f ${CMAKE_CURRENT_SOURCE_DIR}/allredopttf.f ${CMAKE_CURRENT_SOURCE_DIR}/alltoallvf.f ${CMAKE_CURRENT_SOURCE_DIR}/alltoallwf.f ${CMAKE_CURRENT_SOURCE_DIR}/exscanf.f ${CMAKE_CURRENT_SOURCE_DIR}/inplacef.f ${CMAKE_CURRENT_SOURCE_DIR}/nonblockingf.f ${CMAKE_CURRENT_SOURCE_DIR}/nonblocking_inpf.f ${CMAKE_CURRENT_SOURCE_DIR}/red_scat_blockf.f ${CMAKE_CURRENT_SOURCE_DIR}/redscatf.f ${CMAKE_CURRENT_SOURCE_DIR}/reducelocalf.f ${CMAKE_CURRENT_SOURCE_DIR}/split_typef.f ${CMAKE_CURRENT_SOURCE_DIR}/uallreducef.f ${CMAKE_CURRENT_SOURCE_DIR}/vw_inplacef.f PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/comm/000755 001750 001750 00000000000 12342443666 020521 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/comm/testlist000644 001750 001750 00000000031 12342443666 022311 0ustar00cici000000 000000 #commnamef 2 #commerrf 2 SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/comm/commnamef.f000644 001750 001750 00000004432 12342443662 022631 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer errs, ierr integer comm(4), i, rlen, ln integer ncomm character*(MPI_MAX_OBJECT_NAME) inname(4), cname logical MTestGetIntracomm errs = 0 call mtest_init( ierr ) C Test the predefined communicators do ln=1,MPI_MAX_OBJECT_NAME cname(ln:ln) = 'X' enddo call mpi_comm_get_name( MPI_COMM_WORLD, cname, rlen, ierr ) do ln=MPI_MAX_OBJECT_NAME,1,-1 if (cname(ln:ln) .ne. ' ') then if (ln .ne. rlen) then errs = errs + 1 print *, 'result len ', rlen,' not equal to actual len ', & ln endif goto 110 endif enddo if (cname(1:rlen) .ne. 'MPI_COMM_WORLD') then errs = errs + 1 print *, 'Did not get MPI_COMM_WORLD for world' endif 110 continue C do ln=1,MPI_MAX_OBJECT_NAME cname(ln:ln) = 'X' enddo call mpi_comm_get_name( MPI_COMM_SELF, cname, rlen, ierr ) do ln=MPI_MAX_OBJECT_NAME,1,-1 if (cname(ln:ln) .ne. ' ') then if (ln .ne. rlen) then errs = errs + 1 print *, 'result len ', rlen,' not equal to actual len ', & ln endif goto 120 endif enddo if (cname(1:rlen) .ne. 'MPI_COMM_SELF') then errs = errs + 1 print *, 'Did not get MPI_COMM_SELF for world' endif 120 continue C do i = 1, 4 if (MTestGetIntracomm( comm(i), 1, .true. )) then ncomm = i write( inname(i), '(a,i1)') 'myname',i call mpi_comm_set_name( comm(i), inname(i), ierr ) else goto 130 endif enddo 130 continue C C Now test them all do i=1, ncomm call mpi_comm_get_name( comm(i), cname, rlen, ierr ) if (inname(i) .ne. cname) then errs = errs + 1 print *, ' Expected ', inname(i), ' got ', cname endif call MTestFreeComm( comm(i) ) enddo C call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/comm/commerrf.f000644 001750 001750 00000010644 12342443662 022503 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer errs, ierr, code(2), newerrclass, eclass character*(MPI_MAX_ERROR_STRING) errstring integer comm, rlen external myerrhanfunc CF90 INTERFACE CF90 SUBROUTINE myerrhanfunc(vv0,vv1) CF90 INTEGER vv0,vv1 CF90 END SUBROUTINE CF90 END INTERFACE integer myerrhan, qerr integer callcount, codesSeen(3) common /myerrhan/ callcount, codesSeen errs = 0 callcount = 0 call mtest_init( ierr ) C C Setup some new codes and classes call mpi_add_error_class( newerrclass, ierr ) call mpi_add_error_code( newerrclass, code(1), ierr ) call mpi_add_error_code( newerrclass, code(2), ierr ) call mpi_add_error_string( newerrclass, "New Class", ierr ) call mpi_add_error_string( code(1), "First new code", ierr ) call mpi_add_error_string( code(2), "Second new code", ierr ) C C call mpi_comm_create_errhandler( myerrhanfunc, myerrhan, ierr ) C C Create a new communicator so that we can leave the default errors-abort C on MPI_COMM_WORLD call mpi_comm_dup( MPI_COMM_WORLD, comm, ierr ) C call mpi_comm_set_errhandler( comm, myerrhan, ierr ) call mpi_comm_get_errhandler( comm, qerr, ierr ) if (qerr .ne. myerrhan) then errs = errs + 1 print *, ' Did not get expected error handler' endif call mpi_errhandler_free( qerr, ierr ) C We can free our error handler now call mpi_errhandler_free( myerrhan, ierr ) call mpi_comm_call_errhandler( comm, newerrclass, ierr ) call mpi_comm_call_errhandler( comm, code(1), ierr ) call mpi_comm_call_errhandler( comm, code(2), ierr ) if (callcount .ne. 3) then errs = errs + 1 print *, ' Expected 3 calls to error handler, found ', & callcount else if (codesSeen(1) .ne. newerrclass) then errs = errs + 1 print *, 'Expected class ', newerrclass, ' got ', & codesSeen(1) endif if (codesSeen(2) .ne. code(1)) then errs = errs + 1 print *, 'Expected code ', code(1), ' got ', & codesSeen(2) endif if (codesSeen(3) .ne. code(2)) then errs = errs + 1 print *, 'Expected code ', code(2), ' got ', & codesSeen(3) endif endif call mpi_comm_free( comm, ierr ) C C Check error strings while here... call mpi_error_string( newerrclass, errstring, rlen, ierr ) if (errstring(1:rlen) .ne. "New Class") then errs = errs + 1 print *, ' Wrong string for error class: ', errstring(1:rlen) endif call mpi_error_class( code(1), eclass, ierr ) if (eclass .ne. newerrclass) then errs = errs + 1 print *, ' Class for new code is not correct' endif call mpi_error_string( code(1), errstring, rlen, ierr ) if (errstring(1:rlen) .ne. "First new code") then errs = errs + 1 print *, ' Wrong string for error code: ', errstring(1:rlen) endif call mpi_error_class( code(2), eclass, ierr ) if (eclass .ne. newerrclass) then errs = errs + 1 print *, ' Class for new code is not correct' endif call mpi_error_string( code(2), errstring, rlen, ierr ) if (errstring(1:rlen) .ne. "Second new code") then errs = errs + 1 print *, ' Wrong string for error code: ', errstring(1:rlen) endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end C subroutine myerrhanfunc( comm, errcode ) implicit none include 'mpif.h' integer comm, errcode integer rlen, ierr integer callcount, codesSeen(3) character*(MPI_MAX_ERROR_STRING) errstring common /myerrhan/ callcount, codesSeen callcount = callcount + 1 C Remember the code we've seen if (callcount .le. 3) then codesSeen(callcount) = errcode endif call mpi_error_string( errcode, errstring, rlen, ierr ) if (ierr .ne. MPI_SUCCESS) then print *, ' Panic! could not get error string' call mpi_abort( MPI_COMM_WORLD, 1, ierr ) endif end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/comm/CMakeLists.txt000644 001750 001750 00000002136 12342443654 023260 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite AND SMPI_F2C) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include/") # add_executable(commerrf commerrf.f) # add_executable(commnamef commnamef.f) # target_link_libraries(commerrf simgrid mtest_f77) # target_link_libraries(commnamef simgrid mtest_f77) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/commerrf.f ${CMAKE_CURRENT_SOURCE_DIR}/commnamef.f PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/pt2pt/000755 001750 001750 00000000000 12342443666 020637 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/pt2pt/dummyf.f000644 001750 001750 00000001306 12342443662 022303 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2010 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C C C This file is used to disable certain compiler optimizations that C can cause incorrect results with the test in greqf.f. It provides a C point where extrastate may be modified, limiting the compilers ability C to move code around. C The include of mpif.h is not needed in the F77 case but in the C F90 case it is, because in that case, extrastate is defined as an C integer (kind=MPI_ADDRESS_KIND), and the script that creates the C F90 tests from the F77 tests looks for mpif.h subroutine dummyupdate( extrastate ) include 'mpif.h' include 'attr1aints.h' end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/pt2pt/testlist000644 001750 001750 00000000071 12342443666 022433 0ustar00cici000000 000000 statusesf 1 #greqf 1 allpairf 2 mprobef 2 mpiversion=3.0 SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/pt2pt/attr1aints.h000644 001750 001750 00000000245 12342443662 023077 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C integer extrastate, valin, valout, val SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/pt2pt/mprobef.f000644 001750 001750 00000057213 12342443662 022444 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2012 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none include 'mpif.h' integer idx, ierr, rank, size, count integer sendbuf(8), recvbuf(8) integer s1(MPI_STATUS_SIZE), s2(MPI_STATUS_SIZE) integer msg, errs integer rreq logical found, flag ierr = -1 errs = 0 call mpi_init( ierr ) if (ierr .ne. MPI_SUCCESS) then errs = errs + 1 print *, ' Unexpected return from MPI_INIT', ierr endif call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) call mpi_comm_size( MPI_COMM_WORLD, size, ierr ) if (size .lt. 2) then errs = errs + 1 print *, ' This test requires at least 2 processes' C Abort now - do not continue in this case. call mpi_abort( MPI_COMM_WORLD, 1, ierr ) endif if (size .gt. 2) then print *, ' This test is running with ', size, ' processes,' print *, ' only 2 processes are used.' endif C Test 0: simple Send and Mprobe+Mrecv. if (rank .eq. 0) then sendbuf(1) = 1735928559 sendbuf(2) = 1277009102 call MPI_Send(sendbuf, 2, MPI_INTEGER, . 1, 5, MPI_COMM_WORLD, ierr) else do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo C the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER msg = MPI_MESSAGE_NULL call MPI_Mprobe(0, 5, MPI_COMM_WORLD, msg, s1, ierr) if (s1(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's1(MPI_SOURCE) != 0 at T0 Mprobe().' endif if (s1(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's1(MPI_TAG) != 5 at T0 Mprobe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T0 Mprobe().' endif if (msg .eq. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg == MPI_MESSAGE_NULL at T0 Mprobe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 2) then errs = errs + 1 print *, 'probed buffer does not have 2 MPI_INTEGERs.' endif recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Mrecv(recvbuf, count, MPI_INTEGER, msg, s2, ierr) if (recvbuf(1) .ne. 1735928559) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T0 Mrecv().' endif if (recvbuf(2) .ne. 1277009102) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T0 Mrecv().' endif if (s2(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's2(MPI_SOURCE) != 0 at T0 Mrecv().' endif if (s2(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's2(MPI_TAG) != 5 at T0 Mrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T0 Mrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T0 Mrecv().' endif endif C Test 1: simple Send and Mprobe+Imrecv. if (rank .eq. 0) then sendbuf(1) = 1735928559 sendbuf(2) = 1277009102 call MPI_Send(sendbuf, 2, MPI_INTEGER, . 1, 5, MPI_COMM_WORLD, ierr) else do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo C the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER msg = MPI_MESSAGE_NULL call MPI_Mprobe(0, 5, MPI_COMM_WORLD, msg, s1, ierr) if (s1(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's1(MPI_SOURCE) != 0 at T1 Mprobe().' endif if (s1(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's1(MPI_TAG) != 5 at T1 Mprobe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T1 Mprobe().' endif if (msg .eq. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg == MPI_MESSAGE_NULL at T1 Mprobe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 2) then errs = errs + 1 print *, 'probed buffer does not have 2 MPI_INTEGERs.' endif rreq = MPI_REQUEST_NULL recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Imrecv(recvbuf, count, MPI_INTEGER, msg, rreq, ierr) if (rreq .eq. MPI_REQUEST_NULL) then errs = errs + 1 print *, 'rreq is unmodified at T1 Imrecv().' endif call MPI_Wait(rreq, s2, ierr) if (recvbuf(1) .ne. 1735928559) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T1 Imrecv().' endif if (recvbuf(2) .ne. 1277009102) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T1 Imrecv().' endif if (s2(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's2(MPI_SOURCE) != 0 at T1 Imrecv().' endif if (s2(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's2(MPI_TAG) != 5 at T1 Imrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T1 Imrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T1 Imrecv().' endif endif C Test 2: simple Send and Improbe+Mrecv. if (rank .eq. 0) then sendbuf(1) = 1735928559 sendbuf(2) = 1277009102 call MPI_Send(sendbuf, 2, MPI_INTEGER, . 1, 5, MPI_COMM_WORLD, ierr) else do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo C the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER msg = MPI_MESSAGE_NULL call MPI_Improbe(0, 5, MPI_COMM_WORLD, found, msg, s1, ierr) do while (.not. found) call MPI_Improbe(0, 5, MPI_COMM_WORLD, . found, msg, s1, ierr) enddo if (msg .eq. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg == MPI_MESSAGE_NULL at T2 Improbe().' endif if (s1(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's1(MPI_SOURCE) != 0 at T2 Improbe().' endif if (s1(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's1(MPI_TAG) != 5 at T2 Improbe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T2 Improbe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 2) then errs = errs + 1 print *, 'probed buffer does not have 2 MPI_INTEGERs.' endif recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Mrecv(recvbuf, count, MPI_INTEGER, msg, s2, ierr) if (recvbuf(1) .ne. 1735928559) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T2 Mrecv().' endif if (recvbuf(2) .ne. 1277009102) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T2 Mrecv().' endif if (s2(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's2(MPI_SOURCE) != 0 at T2 Mrecv().' endif if (s2(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's2(MPI_TAG) != 5 at T2 Mrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T2 Mrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T2 Mrecv().' endif endif C Test 3: simple Send and Improbe+Imrecv. if (rank .eq. 0) then sendbuf(1) = 1735928559 sendbuf(2) = 1277009102 call MPI_Send(sendbuf, 2, MPI_INTEGER, . 1, 5, MPI_COMM_WORLD, ierr) else do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo C the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER msg = MPI_MESSAGE_NULL call MPI_Improbe(0, 5, MPI_COMM_WORLD, found, msg, s1, ierr) do while (.not. found) call MPI_Improbe(0, 5, MPI_COMM_WORLD, . found, msg, s1, ierr) enddo if (msg .eq. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg == MPI_MESSAGE_NULL at T3 Improbe().' endif if (s1(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's1(MPI_SOURCE) != 0 at T3 Improbe().' endif if (s1(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's1(MPI_TAG) != 5 at T3 Improbe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T3 Improbe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 2) then errs = errs + 1 print *, 'probed buffer does not have 2 MPI_INTEGERs.' endif rreq = MPI_REQUEST_NULL recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Imrecv(recvbuf, count, MPI_INTEGER, msg, rreq, ierr) if (rreq .eq. MPI_REQUEST_NULL) then errs = errs + 1 print *, 'rreq is unmodified at T3 Imrecv().' endif call MPI_Wait(rreq, s2, ierr) if (recvbuf(1) .ne. 1735928559) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T3 Imrecv().' endif if (recvbuf(2) .ne. 1277009102) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T3 Imrecv().' endif if (s2(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's2(MPI_SOURCE) != 0 at T3 Imrecv().' endif if (s2(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's2(MPI_TAG) != 5 at T3 Imrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T3 Imrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T3 Imrecv().' endif endif C Test 4: Mprobe+Mrecv with MPI_PROC_NULL if (.true.) then do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo C the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER msg = MPI_MESSAGE_NULL call MPI_Mprobe(MPI_PROC_NULL, 5, MPI_COMM_WORLD, . msg, s1, ierr) if (s1(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's1(MPI_SOURCE) != MPI_PROC_NULL at T4 Mprobe().' endif if (s1(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's1(MPI_TAG) != MPI_ANY_TAG at T4 Mprobe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T4 Mprobe().' endif if (msg .ne. MPI_MESSAGE_NO_PROC) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NO_PROC at T4 Mprobe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'probed buffer does not have 0 MPI_INTEGER.' endif recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Mrecv(recvbuf, count, MPI_INTEGER, msg, s2, ierr) C recvbuf() should remain unmodified if (recvbuf(1) .ne. 19088743) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T4 Mrecv().' endif if (recvbuf(2) .ne. 1309737967) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T4 Mrecv().' endif if (s2(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's2(MPI_SOURCE) != MPI_PROC_NULL at T4 Mrecv().' endif if (s2(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's2(MPI_TAG) != MPI_ANY_TAG at T4 Mrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T4 Mrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T4 Mrecv().' endif count = -1 call MPI_Get_count(s2, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'recv buffer does not have 0 MPI_INTEGER.' endif endif C Test 5: Mprobe+Imrecv with MPI_PROC_NULL if (.true.) then do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo C the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER msg = MPI_MESSAGE_NULL call MPI_Mprobe(MPI_PROC_NULL, 5, MPI_COMM_WORLD, . msg, s1, ierr) if (s1(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's1(MPI_SOURCE) != MPI_PROC_NULL at T5 Mprobe().' endif if (s1(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's1(MPI_TAG) != MPI_ANY_TAG at T5 Mprobe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T5 Mprobe().' endif if (msg .ne. MPI_MESSAGE_NO_PROC) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NO_PROC at T5 Mprobe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'probed buffer does not have 0 MPI_INTEGER.' endif rreq = MPI_REQUEST_NULL recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Imrecv(recvbuf, count, MPI_INTEGER, msg, rreq, ierr) if (rreq .eq. MPI_REQUEST_NULL) then errs = errs + 1 print *, 'rreq == MPI_REQUEST_NULL at T5 Imrecv().' endif flag = .false. call MPI_Test(rreq, flag, s2, ierr) if (.not. flag) then errs = errs + 1 print *, 'flag is false at T5 Imrecv().' endif C recvbuf() should remain unmodified if (recvbuf(1) .ne. 19088743) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T5 Imrecv().' endif if (recvbuf(2) .ne. 1309737967) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T5 Imrecv().' endif if (s2(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's2(MPI_SOURCE) != MPI_PROC_NULL at T5 Imrecv().' endif if (s2(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's2(MPI_TAG) != MPI_ANY_TAG at T5 Imrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T5 Imrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T5 Imrecv().' endif count = -1 call MPI_Get_count(s2, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'recv buffer does not have 0 MPI_INTEGER.' endif endif C Test 6: Improbe+Mrecv with MPI_PROC_NULL if (.true.) then do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo C the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER found = .false. msg = MPI_MESSAGE_NULL call MPI_Improbe(MPI_PROC_NULL, 5, MPI_COMM_WORLD, . found, msg, s1, ierr) if (.not. found) then errs = errs + 1 print *, 'found is false at T6 Improbe().' endif if (s1(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's1(MPI_SOURCE) != MPI_PROC_NULL at T6 Improbe()' endif if (s1(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's1(MPI_TAG) != MPI_ANY_TAG at T6 Improbe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T6 Improbe().' endif if (msg .ne. MPI_MESSAGE_NO_PROC) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NO_PROC at T6 Improbe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'probed buffer does not have 0 MPI_INTEGER.' endif recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Mrecv(recvbuf, count, MPI_INTEGER, msg, s2, ierr) C recvbuf() should remain unmodified if (recvbuf(1) .ne. 19088743) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T6 Mrecv().' endif if (recvbuf(2) .ne. 1309737967) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T6 Mrecv().' endif if (s2(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's2(MPI_SOURCE) != MPI_PROC_NULL at T6 Mrecv().' endif if (s2(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's2(MPI_TAG) != MPI_ANY_TAG at T6 Mrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T6 Mrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T6 Mrecv().' endif count = -1 call MPI_Get_count(s2, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'recv buffer does not have 0 MPI_INTEGER.' endif endif C Test 7: Improbe+Imrecv with MPI_PROC_NULL if (.true.) then do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo C the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER found = .false. msg = MPI_MESSAGE_NULL call MPI_Improbe(MPI_PROC_NULL, 5, MPI_COMM_WORLD, . found, msg, s1, ierr) if (.not. found) then errs = errs + 1 print *, 'found is false at T7 Improbe().' endif if (s1(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's1(MPI_SOURCE) != MPI_PROC_NULL at T7 Improbe()' endif if (s1(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's1(MPI_TAG) != MPI_ANY_TAG at T7 Improbe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T7 Improbe().' endif if (msg .ne. MPI_MESSAGE_NO_PROC) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NO_PROC at T7 Improbe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'probed buffer does not have 0 MPI_INTEGER.' endif rreq = MPI_REQUEST_NULL recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Imrecv(recvbuf, count, MPI_INTEGER, msg, rreq, ierr) if (rreq .eq. MPI_REQUEST_NULL) then errs = errs + 1 print *, 'rreq == MPI_REQUEST_NULL at T7 Imrecv().' endif flag = .false. call MPI_Test(rreq, flag, s2, ierr) if (.not. flag) then errs = errs + 1 print *, 'flag is false at T7 Imrecv().' endif C recvbuf() should remain unmodified if (recvbuf(1) .ne. 19088743) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T7 Imrecv().' endif if (recvbuf(2) .ne. 1309737967) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T7 Imrecv().' endif if (s2(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's2(MPI_SOURCE) != MPI_PROC_NULL at T7 Imrecv().' endif if (s2(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's2(MPI_TAG) != MPI_ANY_TAG at T7 Imrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T7 Imrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T7 Imrecv().' endif count = -1 call MPI_Get_count(s2, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'recv buffer does not have 0 MPI_INTEGER.' endif endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/pt2pt/allpairf.f000644 001750 001750 00000072564 12342443662 022612 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2012 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C C This program is based on the allpair.f test from the MPICH-1 test C (test/pt2pt/allpair.f), which in turn was inspired by a bug report from C fsset@corelli.lerc.nasa.gov (Scott Townsend) program allpair implicit none include 'mpif.h' integer ierr, errs, comm logical mtestGetIntraComm logical verbose common /flags/ verbose errs = 0 verbose = .false. C verbose = .true. call MTest_Init( ierr ) do while ( mtestGetIntraComm( comm, 2, .false. ) ) call test_pair_send( comm, errs ) call test_pair_ssend( comm, errs ) !call test_pair_rsend( comm, errs ) call test_pair_isend( comm, errs ) !call test_pair_irsend( comm, errs ) call test_pair_issend( comm, errs ) !call test_pair_psend( comm, errs ) !call test_pair_prsend( comm, errs ) call test_pair_pssend( comm, errs ) call test_pair_sendrecv( comm, errs ) call test_pair_sendrecvrepl( comm, errs ) call mtestFreeComm( comm ) enddo C call MTest_Finalize( errs ) call MPI_Finalize(ierr) C end C subroutine test_pair_send( comm, errs ) implicit none include 'mpif.h' integer comm, errs integer rank, size, ierr, next, prev, tag, count integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE) real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose C if (verbose) then print *, ' Send and recv' endif C call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 C prev = rank - 1 if (prev .lt. 0) prev = size - 1 C tag = 1123 count = TEST_SIZE / 5 C call clear_test_data(recv_buf,TEST_SIZE) C if (rank .eq. 0) then C call init_test_data(send_buf,TEST_SIZE) C call MPI_Send(send_buf, count, MPI_REAL, next, tag, . comm, ierr) C call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, status, ierr) C call msg_check( recv_buf, next, tag, count, status, TEST_SIZE, . 'send and recv', errs ) else if (prev .eq. 0) then call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, status, ierr) call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, . 'send and recv', errs ) C call MPI_Send(recv_buf, count, MPI_REAL, prev, tag, comm, ierr) end if C end C subroutine test_pair_rsend( comm, errs ) implicit none include 'mpif.h' integer comm, errs integer rank, size, ierr, next, prev, tag, count, i integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE), requests(1) real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose C if (verbose) then print *, ' Rsend and recv' endif C C call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 C prev = rank - 1 if (prev .lt. 0) prev = size - 1 C tag = 1456 count = TEST_SIZE / 3 C call clear_test_data(recv_buf,TEST_SIZE) C if (rank .eq. 0) then C call init_test_data(send_buf,TEST_SIZE) C call MPI_Recv( MPI_BOTTOM, 0, MPI_INTEGER, next, tag, . comm, status, ierr ) C call MPI_Rsend(send_buf, count, MPI_REAL, next, tag, . comm, ierr) C call MPI_Probe(MPI_ANY_SOURCE, tag, comm, status, ierr) C if (status(MPI_SOURCE) .ne. next) then print *, 'Rsend: Incorrect source, expected', next, . ', got', status(MPI_SOURCE) errs = errs + 1 end if C if (status(MPI_TAG) .ne. tag) then print *, 'Rsend: Incorrect tag, expected', tag, . ', got', status(MPI_TAG) errs = errs + 1 end if C call MPI_Get_count(status, MPI_REAL, i, ierr) C if (i .ne. count) then print *, 'Rsend: Incorrect count, expected', count, . ', got', i errs = errs + 1 end if C call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . status, ierr) C call msg_check( recv_buf, next, tag, count, status, TEST_SIZE, . 'rsend and recv', errs ) C else if (prev .eq. 0) then C call MPI_Irecv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . requests(1), ierr) call MPI_Send( MPI_BOTTOM, 0, MPI_INTEGER, prev, tag, . comm, ierr ) call MPI_Wait( requests(1), status, ierr ) call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, . 'rsend and recv', errs ) C call MPI_Send(recv_buf, count, MPI_REAL, prev, tag, . comm, ierr) end if C end C subroutine test_pair_ssend( comm, errs ) implicit none include 'mpif.h' integer comm, errs integer rank, size, ierr, next, prev, tag, count, i integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE) logical flag real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose C if (verbose) then print *, ' Ssend and recv' endif C C call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 C prev = rank - 1 if (prev .lt. 0) prev = size - 1 C tag = 1789 count = TEST_SIZE / 3 C call clear_test_data(recv_buf,TEST_SIZE) C if (rank .eq. 0) then C call init_test_data(send_buf,TEST_SIZE) C call MPI_Iprobe(MPI_ANY_SOURCE, tag, . comm, flag, status, ierr) C if (flag) then print *, 'Ssend: Iprobe succeeded! source', . status(MPI_SOURCE), . ', tag', status(MPI_TAG) errs = errs + 1 end if C call MPI_Ssend(send_buf, count, MPI_REAL, next, tag, . comm, ierr) C do while (.not. flag) call MPI_Iprobe(MPI_ANY_SOURCE, tag, . comm, flag, status, ierr) end do C if (status(MPI_SOURCE) .ne. next) then print *, 'Ssend: Incorrect source, expected', next, . ', got', status(MPI_SOURCE) errs = errs + 1 end if C if (status(MPI_TAG) .ne. tag) then print *, 'Ssend: Incorrect tag, expected', tag, . ', got', status(MPI_TAG) errs = errs + 1 end if C call MPI_Get_count(status, MPI_REAL, i, ierr) C if (i .ne. count) then print *, 'Ssend: Incorrect count, expected', count, . ', got', i errs = errs + 1 end if C call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . status, ierr) C call msg_check( recv_buf, next, tag, count, status, . TEST_SIZE, 'ssend and recv', errs ) C else if (prev .eq. 0) then C call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . status, ierr) C call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, . 'ssend and recv', errs ) C call MPI_Ssend(recv_buf, count, MPI_REAL, prev, tag, . comm, ierr) end if C end C subroutine test_pair_isend( comm, errs ) implicit none include 'mpif.h' integer comm, errs integer rank, size, ierr, next, prev, tag, count integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE), requests(2) integer statuses(MPI_STATUS_SIZE,2) real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose C if (verbose) then print *, ' isend and irecv' endif C C call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 C prev = rank - 1 if (prev .lt. 0) prev = size - 1 C tag = 2123 count = TEST_SIZE / 5 C call clear_test_data(recv_buf,TEST_SIZE) C if (rank .eq. 0) then C call MPI_Irecv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . requests(1), ierr) C call init_test_data(send_buf,TEST_SIZE) C call MPI_Isend(send_buf, count, MPI_REAL, next, tag, . comm, requests(2), ierr) C call MPI_Waitall(2, requests, statuses, ierr) C call rq_check( requests, 2, 'isend and irecv' ) C call msg_check( recv_buf, next, tag, count, statuses(1,1), . TEST_SIZE, 'isend and irecv', errs ) C else if (prev .eq. 0) then C call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . status, ierr) C call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, . 'isend and irecv', errs ) C call MPI_Isend(recv_buf, count, MPI_REAL, prev, tag, . comm, requests(1), ierr) C call MPI_Wait(requests(1), status, ierr) C C call rq_check( requests(1), 1, 'isend and irecv' ) C end if C end C subroutine test_pair_irsend( comm, errs ) implicit none include 'mpif.h' integer comm, errs integer rank, size, ierr, next, prev, tag, count, index, i integer TEST_SIZE integer dupcom parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE), requests(2) integer statuses(MPI_STATUS_SIZE,2) logical flag real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose C if (verbose) then print *, ' Irsend and irecv' endif C call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 C prev = rank - 1 if (prev .lt. 0) prev = size - 1 C call mpi_comm_dup( comm, dupcom, ierr ) C tag = 2456 count = TEST_SIZE / 3 C call clear_test_data(recv_buf,TEST_SIZE) C if (rank .eq. 0) then C call MPI_Irecv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . requests(1), ierr) C call init_test_data(send_buf,TEST_SIZE) C call MPI_Sendrecv( MPI_BOTTOM, 0, MPI_INTEGER, next, 0, . MPI_BOTTOM, 0, MPI_INTEGER, next, 0, . dupcom, status, ierr ) C call MPI_Irsend(send_buf, count, MPI_REAL, next, tag, . comm, requests(2), ierr) C index = -1 do while (index .ne. 1) call MPI_Waitany(2, requests, index, statuses, ierr) end do C call rq_check( requests(1), 1, 'irsend and irecv' ) C call msg_check( recv_buf, next, tag, count, statuses, . TEST_SIZE, 'irsend and irecv', errs ) C else if (prev .eq. 0) then C call MPI_Irecv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . requests(1), ierr) C call MPI_Sendrecv( MPI_BOTTOM, 0, MPI_INTEGER, prev, 0, . MPI_BOTTOM, 0, MPI_INTEGER, prev, 0, . dupcom, status, ierr ) C flag = .FALSE. do while (.not. flag) call MPI_Test(requests(1), flag, status, ierr) end do C call rq_check( requests, 1, 'irsend and irecv (test)' ) C call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, . 'irsend and irecv', errs ) C call MPI_Irsend(recv_buf, count, MPI_REAL, prev, tag, . comm, requests(1), ierr) C call MPI_Waitall(1, requests, statuses, ierr) C call rq_check( requests, 1, 'irsend and irecv' ) C end if C call mpi_comm_free( dupcom, ierr ) C end C subroutine test_pair_issend( comm, errs ) implicit none include 'mpif.h' integer comm, errs integer rank, size, ierr, next, prev, tag, count, index integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE), requests(2) integer statuses(MPI_STATUS_SIZE,2) logical flag real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose C if (verbose) then print *, ' issend and irecv (testall)' endif C C call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 C prev = rank - 1 if (prev .lt. 0) prev = size - 1 C tag = 2789 count = TEST_SIZE / 3 C call clear_test_data(recv_buf,TEST_SIZE) C if (rank .eq. 0) then C call MPI_Irecv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . requests(1), ierr) C call init_test_data(send_buf,TEST_SIZE) C call MPI_Issend(send_buf, count, MPI_REAL, next, tag, . comm, requests(2), ierr) C flag = .FALSE. do while (.not. flag) call MPI_Testall(2, requests, flag, statuses, ierr) end do C call rq_check( requests, 2, 'issend and irecv (testall)' ) C call msg_check( recv_buf, next, tag, count, statuses(1,1), . TEST_SIZE, 'issend and recv (testall)', errs ) C else if (prev .eq. 0) then C call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . status, ierr) call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, . 'issend and recv', errs ) call MPI_Issend(recv_buf, count, MPI_REAL, prev, tag, . comm, requests(1), ierr) C flag = .FALSE. do while (.not. flag) call MPI_Testany(1, requests(1), index, flag, . statuses(1,1), ierr) end do C call rq_check( requests, 1, 'issend and recv (testany)' ) C end if C end C subroutine test_pair_psend( comm, errs ) implicit none include 'mpif.h' integer comm, errs integer rank, size, ierr, next, prev, tag, count, i integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE) integer statuses(MPI_STATUS_SIZE,2), requests(2) real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose C if (verbose) then print *, ' Persistent send and recv' endif C call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 C prev = rank - 1 if (prev .lt. 0) prev = size - 1 C tag = 3123 count = TEST_SIZE / 5 C call clear_test_data(recv_buf,TEST_SIZE) call MPI_Recv_init(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . requests(2), ierr) C if (rank .eq. 0) then C call init_test_data(send_buf,TEST_SIZE) C call MPI_Send_init(send_buf, count, MPI_REAL, next, tag, . comm, requests(1), ierr) C call MPI_Startall(2, requests, ierr) call MPI_Waitall(2, requests, statuses, ierr) C call msg_check( recv_buf, next, tag, count, statuses(1,2), . TEST_SIZE, 'persistent send/recv', errs ) C call MPI_Request_free(requests(1), ierr) C else if (prev .eq. 0) then C call MPI_Send_init(send_buf, count, MPI_REAL, prev, tag, . comm, requests(1), ierr) call MPI_Start(requests(2), ierr) call MPI_Wait(requests(2), status, ierr) C call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, * 'persistent send/recv', errs ) C do i = 1,count send_buf(i) = recv_buf(i) end do C call MPI_Start(requests(1), ierr) call MPI_Wait(requests(1), status, ierr) C call MPI_Request_free(requests(1), ierr) end if C call dummyRef( send_buf, count, ierr ) call MPI_Request_free(requests(2), ierr) C end C subroutine test_pair_prsend( comm, errs ) implicit none include 'mpif.h' integer comm, errs integer rank, size, ierr, next, prev, tag, count, index, i integer outcount, indices(2) integer TEST_SIZE parameter (TEST_SIZE=2000) integer statuses(MPI_STATUS_SIZE,2), requests(2) integer status(MPI_STATUS_SIZE) logical flag real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose C if (verbose) then print *, ' Persistent Rsend and recv' endif C call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 C prev = rank - 1 if (prev .lt. 0) prev = size - 1 C tag = 3456 count = TEST_SIZE / 3 C call clear_test_data(recv_buf,TEST_SIZE) C call MPI_Recv_init(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . requests(2), ierr) C if (rank .eq. 0) then C call MPI_Rsend_init(send_buf, count, MPI_REAL, next, tag, . comm, requests(1), ierr) C call init_test_data(send_buf,TEST_SIZE) C call MPI_Recv( MPI_BOTTOM, 0, MPI_INTEGER, next, tag, . comm, status, ierr ) C call MPI_Startall(2, requests, ierr) C index = -1 C do while (index .ne. 2) call MPI_Waitsome(2, requests, outcount, . indices, statuses, ierr) do i = 1,outcount if (indices(i) .eq. 2) then call msg_check( recv_buf, next, tag, count, . statuses(1,i), TEST_SIZE, 'waitsome', errs ) index = 2 end if end do end do C call MPI_Request_free(requests(1), ierr) else if (prev .eq. 0) then C call MPI_Rsend_init(send_buf, count, MPI_REAL, prev, tag, . comm, requests(1), ierr) C call MPI_Start(requests(2), ierr) C call MPI_Send( MPI_BOTTOM, 0, MPI_INTEGER, prev, tag, . comm, ierr ) C flag = .FALSE. do while (.not. flag) call MPI_Test(requests(2), flag, status, ierr) end do call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, . 'test', errs ) C do i = 1,count send_buf(i) = recv_buf(i) end do C call MPI_Start(requests(1), ierr) call MPI_Wait(requests(1), status, ierr) C call MPI_Request_free(requests(1), ierr) end if C call dummyRef( send_buf, count, ierr ) call MPI_Request_free(requests(2), ierr) C end C subroutine test_pair_pssend( comm, errs ) implicit none include 'mpif.h' integer comm, errs integer rank, size, ierr, next, prev, tag, count, index, i integer outcount, indices(2) integer TEST_SIZE parameter (TEST_SIZE=2000) integer statuses(MPI_STATUS_SIZE,2), requests(2) integer status(MPI_STATUS_SIZE) logical flag real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose C if (verbose) then print *, ' Persistent Ssend and recv' endif C call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 C prev = rank - 1 if (prev .lt. 0) prev = size - 1 C tag = 3789 count = TEST_SIZE / 3 C call clear_test_data(recv_buf,TEST_SIZE) C call MPI_Recv_init(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . requests(1), ierr) C if (rank .eq. 0) then C call MPI_Ssend_init(send_buf, count, MPI_REAL, next, tag, . comm, requests(2), ierr) C call init_test_data(send_buf,TEST_SIZE) C call MPI_Startall(2, requests, ierr) C index = -1 do while (index .ne. 1) call MPI_Testsome(2, requests, outcount, . indices, statuses, ierr) do i = 1,outcount if (indices(i) .eq. 1) then call msg_check( recv_buf, next, tag, count, . statuses(1,i), TEST_SIZE, 'testsome', errs ) index = 1 end if end do end do C call MPI_Request_free(requests(2), ierr) C else if (prev .eq. 0) then C call MPI_Ssend_init(send_buf, count, MPI_REAL, prev, tag, . comm, requests(2), ierr) C call MPI_Start(requests(1), ierr) C flag = .FALSE. do while (.not. flag) call MPI_Testany(1, requests(1), index, flag, . statuses(1,1), ierr) end do call msg_check( recv_buf, prev, tag, count, statuses(1,1), . TEST_SIZE, 'testany', errs ) do i = 1,count send_buf(i) = recv_buf(i) end do C call MPI_Start(requests(2), ierr) call MPI_Wait(requests(2), status, ierr) C call MPI_Request_free(requests(2), ierr) C end if C call dummyRef( send_buf, count, ierr ) call MPI_Request_free(requests(1), ierr) C end C subroutine test_pair_sendrecv( comm, errs ) implicit none include 'mpif.h' integer comm, errs integer rank, size, ierr, next, prev, tag, count integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE) real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose C if (verbose) then print *, ' Sendrecv' endif C C call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 C prev = rank - 1 if (prev .lt. 0) prev = size - 1 C tag = 4123 count = TEST_SIZE / 5 call clear_test_data(recv_buf,TEST_SIZE) if (rank .eq. 0) then call init_test_data(send_buf,TEST_SIZE) call MPI_Sendrecv(send_buf, count, MPI_REAL, next, tag, . recv_buf, count, MPI_REAL, next, tag, . comm, status, ierr) call msg_check( recv_buf, next, tag, count, status, TEST_SIZE, . 'sendrecv', errs ) else if (prev .eq. 0) then call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . status, ierr) call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, . 'recv/send', errs ) call MPI_Send(recv_buf, count, MPI_REAL, prev, tag, . comm, ierr) end if C end C subroutine test_pair_sendrecvrepl( comm, errs ) implicit none include 'mpif.h' integer comm, errs integer rank, size, ierr, next, prev, tag, count, i integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE) real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose C if (verbose) then print *, ' Sendrecv replace' endif C call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 C prev = rank - 1 if (prev .lt. 0) prev = size - 1 C tag = 4456 count = TEST_SIZE / 3 if (rank .eq. 0) then C call init_test_data(recv_buf, TEST_SIZE) C do 11 i = count+1,TEST_SIZE recv_buf(i) = 0.0 11 continue C call MPI_Sendrecv_replace(recv_buf, count, MPI_REAL, . next, tag, next, tag, . comm, status, ierr) call msg_check( recv_buf, next, tag, count, status, TEST_SIZE, . 'sendrecvreplace', errs ) else if (prev .eq. 0) then call clear_test_data(recv_buf,TEST_SIZE) call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, . MPI_ANY_SOURCE, MPI_ANY_TAG, comm, . status, ierr) call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, . 'recv/send for replace', errs ) call MPI_Send(recv_buf, count, MPI_REAL, prev, tag, . comm, ierr) end if C end C c------------------------------------------------------------------------------ c c Check for correct source, tag, count, and data in test message. c c------------------------------------------------------------------------------ subroutine msg_check( recv_buf, source, tag, count, status, n, * name, errs ) implicit none include 'mpif.h' integer n, errs real recv_buf(n) integer source, tag, count, rank, status(MPI_STATUS_SIZE) character*(*) name integer ierr, recv_src, recv_tag, recv_count recv_src = status(MPI_SOURCE) recv_tag = status(MPI_TAG) call MPI_Comm_rank( MPI_COMM_WORLD, rank, ierr ) call MPI_Get_count(status, MPI_REAL, recv_count, ierr) if (recv_src .ne. source) then print *, '[', rank, '] Unexpected source:', recv_src, * ' in ', name errs = errs + 1 end if if (recv_tag .ne. tag) then print *, '[', rank, '] Unexpected tag:', recv_tag, ' in ', name errs = errs + 1 end if if (recv_count .ne. count) then print *, '[', rank, '] Unexpected count:', recv_count, * ' in ', name errs = errs + 1 end if call verify_test_data(recv_buf, count, n, name, errs ) end c------------------------------------------------------------------------------ c c Check that requests have been set to null c c------------------------------------------------------------------------------ subroutine rq_check( requests, n, msg ) include 'mpif.h' integer n, requests(n) character*(*) msg integer i c do 10 i=1, n if (requests(i) .ne. MPI_REQUEST_NULL) then print *, 'Nonnull request in ', msg endif 10 continue c end c------------------------------------------------------------------------------ c c Initialize test data buffer with integral sequence. c c------------------------------------------------------------------------------ subroutine init_test_data(buf,n) integer n real buf(n) integer i do 10 i = 1, n buf(i) = REAL(i) 10 continue end c------------------------------------------------------------------------------ c c Clear test data buffer c c------------------------------------------------------------------------------ subroutine clear_test_data(buf, n) integer n real buf(n) integer i do 10 i = 1, n buf(i) = 0. 10 continue end c------------------------------------------------------------------------------ c c Verify test data buffer c c------------------------------------------------------------------------------ subroutine verify_test_data( buf, count, n, name, errs ) implicit none include 'mpif.h' integer n, errs real buf(n) character *(*) name integer count, ierr, i C do 10 i = 1, count if (buf(i) .ne. REAL(i)) then print 100, buf(i), i, count, name errs = errs + 1 endif 10 continue C do 20 i = count + 1, n if (buf(i) .ne. 0.) then print 100, buf(i), i, n, name errs = errs + 1 endif 20 continue C 100 format('Invalid data', f6.1, ' at ', i4, ' of ', i4, ' in ', a) C end C C This routine is used to prevent the compiler from deallocating the C array "a", which may happen in some of the tests (see the text in C the MPI standard about why this may be a problem in valid Fortran C codes). Without this, for example, tests fail with the Cray ftn C compiler. C subroutine dummyRef( a, n, ie ) integer n, ie real a(n) C This condition will never be true, but the compile won't know that if (ie .eq. -1) then print *, a(n) endif return end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/pt2pt/greqf.f000644 001750 001750 00000006605 12342443662 022115 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C subroutine query_fn( extrastate, status, ierr ) implicit none include 'mpif.h' integer status(MPI_STATUS_SIZE), ierr include 'attr1aints.h' C C set a default status status(MPI_SOURCE) = MPI_UNDEFINED status(MPI_TAG) = MPI_UNDEFINED call mpi_status_set_cancelled( status, .false., ierr) call mpi_status_set_elements( status, MPI_BYTE, 0, ierr ) ierr = MPI_SUCCESS end C subroutine free_fn( extrastate, ierr ) implicit none include 'mpif.h' integer value, ierr include 'attr1aints.h' integer freefncall common /fnccalls/ freefncall C C For testing purposes, the following print can be used to check whether C the free_fn is called C print *, 'Free_fn called' C extrastate = extrastate - 1 C The value returned by the free function is the error code C returned by the wait/test function ierr = MPI_SUCCESS end C subroutine cancel_fn( extrastate, complete, ierr ) implicit none include 'mpif.h' integer ierr logical complete include 'attr1aints.h' ierr = MPI_SUCCESS end C C C This is a very simple test of generalized requests. Normally, the C MPI_Grequest_complete function would be called from another routine, C often running in a separate thread. This simple code allows us to C check that requests can be created, tested, and waited on in the C case where the request is complete before the wait is called. C C Note that MPI did *not* define a routine that can be called within C test or wait to advance the state of a generalized request. C Most uses of generalized requests will need to use a separate thread. C program main implicit none include 'mpif.h' integer errs, ierr logical flag integer status(MPI_STATUS_SIZE) integer request external query_fn, free_fn, cancel_fn include 'attr1aints.h' integer freefncall common /fnccalls/ freefncall errs = 0 freefncall = 0 call MTest_Init( ierr ) extrastate = 0 call mpi_grequest_start( query_fn, free_fn, cancel_fn, & extrastate, request, ierr ) call mpi_test( request, flag, status, ierr ) if (flag) then errs = errs + 1 print *, 'Generalized request marked as complete' endif call mpi_grequest_complete( request, ierr ) call MPI_Wait( request, status, ierr ) extrastate = 1 call mpi_grequest_start( query_fn, free_fn, cancel_fn, & extrastate, request, ierr ) call mpi_grequest_complete( request, ierr ) call mpi_wait( request, MPI_STATUS_IGNORE, ierr ) C C The following routine may prevent an optimizing compiler from C just remembering that extrastate was set in grequest_start call dummyupdate(extrastate) if (extrastate .ne. 0) then errs = errs + 1 if (freefncall .eq. 0) then print *, 'Free routine not called' else print *, 'Free routine did not update extra_data' print *, 'extrastate = ', extrastate endif endif C call MTest_Finalize( errs ) call mpi_finalize( ierr ) end C SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/pt2pt/statusesf.f000644 001750 001750 00000003162 12342443662 023025 0ustar00cici000000 000000 C -*- Mode: Fortran; -*- C C (C) 2003 by Argonne National Laboratory. C See COPYRIGHT in top-level directory. C program main implicit none C Test support for MPI_STATUS_IGNORE and MPI_STATUSES_IGNORE include 'mpif.h' integer nreqs parameter (nreqs = 100) integer reqs(nreqs) integer ierr, rank, i integer errs ierr = -1 errs = 0 call mpi_init( ierr ) if (ierr .ne. MPI_SUCCESS) then errs = errs + 1 print *, 'Unexpected return from MPI_INIT', ierr endif ierr = -1 call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) if (ierr .ne. MPI_SUCCESS) then errs = errs + 1 print *, 'Unexpected return from MPI_COMM_WORLD', ierr endif do i=1, nreqs, 2 ierr = -1 call mpi_isend( MPI_BOTTOM, 0, MPI_BYTE, rank, i, $ MPI_COMM_WORLD, reqs(i), ierr ) if (ierr .ne. MPI_SUCCESS) then errs = errs + 1 print *, 'Unexpected return from MPI_ISEND', ierr endif ierr = -1 call mpi_irecv( MPI_BOTTOM, 0, MPI_BYTE, rank, i, $ MPI_COMM_WORLD, reqs(i+1), ierr ) if (ierr .ne. MPI_SUCCESS) then errs = errs + 1 print *, 'Unexpected return from MPI_IRECV', ierr endif enddo ierr = -1 call mpi_waitall( nreqs, reqs, MPI_STATUSES_IGNORE, ierr ) if (ierr .ne. MPI_SUCCESS) then errs = errs + 1 print *, 'Unexpected return from MPI_WAITALL', ierr endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f77/pt2pt/CMakeLists.txt000644 001750 001750 00000002723 12342443654 023400 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite AND SMPI_F2C) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff") endif() set(CMAKE_INCLUDE_CURRENT_DIR ON) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include/") add_executable(allpairf allpairf.f) # add_executable(greqf greqf.f dummyf.f) #add_executable(mprobef mprobef.f) add_executable(statusesf statusesf.f) target_link_libraries(allpairf simgrid mtest_f77) # target_link_libraries(greqf simgrid mtest_f77) #target_link_libraries(mprobef simgrid mtest_f77) target_link_libraries(statusesf simgrid mtest_f77) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/allpairf.f ${CMAKE_CURRENT_SOURCE_DIR}/attr1aints.h ${CMAKE_CURRENT_SOURCE_DIR}/dummyf.f ${CMAKE_CURRENT_SOURCE_DIR}/greqf.f ${CMAKE_CURRENT_SOURCE_DIR}/mprobef.f ${CMAKE_CURRENT_SOURCE_DIR}/statusesf.f PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/group/000755 001750 001750 00000000000 12342443666 020317 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/group/gtranksperf.c000644 001750 001750 00000010472 12342443662 023011 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2010 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" #include /* for fabs(3) */ /* Measure and compare the relative performance of MPI_Group_translate_ranks * with small and large group2 sizes but a constant number of ranks. This * serves as a performance sanity check for the Scalasca use case where we * translate to MPI_COMM_WORLD ranks. The performance should only depend on the * number of ranks passed, not the size of either group (especially group2). * * This test is probably only meaningful for large-ish process counts, so we may * not be able to run this test by default in the nightlies. */ /* number of iterations used for timing */ #define NUM_LOOPS (1000000) int main( int argc, char *argv[] ) { int errs = 0; int *ranks; int *ranksout; MPI_Group gworld, grev, gself; MPI_Comm comm; MPI_Comm commrev; int rank, size, i; double start, end, time1, time2; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); ranks = malloc(size*sizeof(int)); ranksout = malloc(size*sizeof(int)); if (!ranks || !ranksout) { fprintf(stderr, "out of memory\n"); MPI_Abort(MPI_COMM_WORLD, 1); exit(1); } /* generate a comm with the rank order reversed */ MPI_Comm_split(comm, 0, (size-rank-1), &commrev); MPI_Comm_group(commrev, &grev); MPI_Comm_group(MPI_COMM_SELF, &gself); MPI_Comm_group(comm, &gworld); /* sanity check correctness first */ for (i=0; i < size; i++) { ranks[i] = i; ranksout[i] = -1; } MPI_Group_translate_ranks(grev, size, ranks, gworld, ranksout); for (i=0; i < size; i++) { if (ranksout[i] != (size-i-1)) { if (rank == 0) printf("%d: (gworld) expected ranksout[%d]=%d, got %d\n", rank, i, (size-rank-1), ranksout[i]); ++errs; } } MPI_Group_translate_ranks(grev, size, ranks, gself, ranksout); for (i=0; i < size; i++) { int expected = (i == (size-rank-1) ? 0 : MPI_UNDEFINED); if (ranksout[i] != expected) { if (rank == 0) printf("%d: (gself) expected ranksout[%d]=%d, got %d\n", rank, i, expected, ranksout[i]); ++errs; } } /* now compare relative performance */ /* we needs lots of procs to get a group large enough to have meaningful * numbers. On most testing machines this means that we're oversubscribing * cores in a big way, which might perturb the timing results. So we make * sure everyone started up and then everyone but rank 0 goes to sleep to * let rank 0 do all the timings. */ MPI_Barrier(comm); if (rank != 0) { MTestSleep(10); } else /* rank==0 */ { MTestSleep(1); /* try to avoid timing while everyone else is making syscalls */ MPI_Group_translate_ranks(grev, size, ranks, gworld, ranksout); /*throwaway iter*/ start = MPI_Wtime(); for (i = 0; i < NUM_LOOPS; ++i) { MPI_Group_translate_ranks(grev, size, ranks, gworld, ranksout); } end = MPI_Wtime(); time1 = end - start; MPI_Group_translate_ranks(grev, size, ranks, gself, ranksout); /*throwaway iter*/ start = MPI_Wtime(); for (i = 0; i < NUM_LOOPS; ++i) { MPI_Group_translate_ranks(grev, size, ranks, gself, ranksout); } end = MPI_Wtime(); time2 = end - start; /* complain if the "gworld" time exceeds 2x the "gself" time */ if (fabs(time1 - time2) > (2.00 * time2)) { printf("too much difference in MPI_Group_translate_ranks performance:\n"); printf("time1=%f time2=%f\n", time1, time2); printf("(fabs(time1-time2)/time2)=%f\n", (fabs(time1-time2)/time2)); if (time1 < time2) { printf("also, (time1 #include int main( int argc, char *argv[] ) { MPI_Group g1, g2, g4, g5, g45, selfgroup, g6; int ranks[16], size, rank, myrank, range[1][3]; int errs = 0; int i, rin[16], rout[16], result; MPI_Init(&argc,&argv); MPI_Comm_group( MPI_COMM_WORLD, &g1 ); MPI_Comm_rank( MPI_COMM_WORLD, &myrank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); if (size < 8) { fprintf( stderr, "Test requires 8 processes (16 prefered) only %d provided\n", size ); errs++; } /* 16 members, this process is rank 0, return in group 1 */ ranks[0] = myrank; ranks[1] = 2; ranks[2] = 7; if (myrank == 2) ranks[1] = 3; if (myrank == 7) ranks[2] = 6; MPI_Group_incl( g1, 3, ranks, &g2 ); /* Check the resulting group */ MPI_Group_size( g2, &size ); MPI_Group_rank( g2, &rank ); if (size != 3) { fprintf( stderr, "Size should be %d, is %d\n", 3, size ); errs++; } if (rank != 0) { fprintf( stderr, "Rank should be %d, is %d\n", 0, rank ); errs++; } rin[0] = 0; rin[1] = 1; rin[2] = 2; MPI_Group_translate_ranks( g2, 3, rin, g1, rout ); for (i=0; i<3; i++) { if (rout[i] != ranks[i]) { fprintf( stderr, "translated rank[%d] %d should be %d\n", i, rout[i], ranks[i] ); errs++; } } /* Translate the process of the self group against another group */ MPI_Comm_group( MPI_COMM_SELF, &selfgroup ); rin[0] = 0; MPI_Group_translate_ranks( selfgroup, 1, rin, g1, rout ); if (rout[0] != myrank) { fprintf( stderr, "translated of self is %d should be %d\n", rout[0], myrank ); errs++; } for (i=0; i g2 intersect ( w, g3 ) => g3 intersect ( g2, g3 ) => empty g4 = rincl 1:n-1:2 g5 = rexcl 1:n-1:2 union( g4, g5 ) => world g6 = rincl n-1:1:-1 g7 = rexcl n-1:1:-1 union( g6, g7 ) => concat of entries, similar to world diff( w, g2 ) => g3 */ MPI_Group_free( &g2 ); range[0][0] = 1; range[0][1] = size-1; range[0][2] = 2; MPI_Group_range_excl( g1, 1, range, &g5 ); range[0][0] = 1; range[0][1] = size-1; range[0][2] = 2; MPI_Group_range_incl( g1, 1, range, &g4 ); MPI_Group_union( g4, g5, &g45 ); MPI_Group_compare( MPI_GROUP_EMPTY, g4, &result ); if (result != MPI_UNEQUAL) { errs++; fprintf( stderr, "Comparison with empty group gave %d, not 3\n", result ); } MPI_Group_free( &g4 ); MPI_Group_free( &g5 ); MPI_Group_free( &g45 ); /* Now, duplicate the test, but using negative strides */ range[0][0] = size-1; range[0][1] = 1; range[0][2] = -2; MPI_Group_range_excl( g1, 1, range, &g5 ); range[0][0] = size-1; range[0][1] = 1; range[0][2] = -2; MPI_Group_range_incl( g1, 1, range, &g4 ); MPI_Group_union( g4, g5, &g45 ); MPI_Group_compare( MPI_GROUP_EMPTY, g4, &result ); if (result != MPI_UNEQUAL) { errs++; fprintf( stderr, "Comparison with empty group (formed with negative strides) gave %d, not 3\n", result ); } MPI_Group_free( &g4 ); MPI_Group_free( &g5 ); MPI_Group_free( &g45 ); MPI_Group_free( &g1 ); if (myrank == 0) { if (errs == 0) { printf( " No Errors\n" ); } else { printf( "Found %d errors\n", errs ); } } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/group/groupcreate.c000644 001750 001750 00000004407 12342443662 023004 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include /* stdlib.h Needed for malloc declaration */ #include int main( int argc, char **argv ) { int i, n, n_goal = 2048, n_all, rc, n_ranks, *ranks, rank, size, len; int group_size; MPI_Group *group_array, world_group; char msg[MPI_MAX_ERROR_STRING]; MPI_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); n = n_goal; group_array = (MPI_Group *)malloc( n * sizeof(MPI_Group) ); MPI_Comm_group( MPI_COMM_WORLD, &world_group ); n_ranks = size; ranks = (int *)malloc( size * sizeof(int) ); for (i=0; i #include "mpitest.h" #define MAX_WORLD_SIZE 1024 int main( int argc, char *argv[] ) { int errs = 0; int ranks[MAX_WORLD_SIZE], ranksout[MAX_WORLD_SIZE], ranksin[MAX_WORLD_SIZE]; int range[1][3]; MPI_Group gworld, gself, ngroup, galt; MPI_Comm comm; int rank, size, i, nelms; MTest_Init( &argc, &argv ); MPI_Comm_group( MPI_COMM_SELF, &gself ); comm = MPI_COMM_WORLD; MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); if (size > MAX_WORLD_SIZE) { fprintf( stderr, "This test requires a comm world with no more than %d processes\n", MAX_WORLD_SIZE ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } if (size < 4) { fprintf( stderr, "This test requiers at least 4 processes\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Comm_group( comm, &gworld ); for (i=0; i #include "mpitest.h" int main( int argc, char *argv[] ) { int errs = 0; int rc, result; int ranks[1]; MPI_Group group, outgroup; MPI_Comm comm; MTest_Init( &argc, &argv ); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); while (MTestGetComm( &comm, 1 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_group( comm, &group ); rc = MPI_Group_incl( group, 0, 0, &outgroup ); if (rc) { errs++; MTestPrintError( rc ); printf( "Error in creating an empty group with (0,0)\n" ); /* Some MPI implementations may reject a null "ranks" pointer */ rc = MPI_Group_incl( group, 0, ranks, &outgroup ); if (rc) { errs++; MTestPrintError( rc ); printf( "Error in creating an empty group with (0,ranks)\n" ); } } if (outgroup != MPI_GROUP_EMPTY) { /* Is the group equivalent to group empty? */ rc = MPI_Group_compare( outgroup, MPI_GROUP_EMPTY, &result ); if (result != MPI_IDENT) { errs++; MTestPrintError( rc ); printf( "Did not create a group equivalent to an empty group\n" ); } } rc = MPI_Group_free( &group ); if (rc) { errs++; MTestPrintError( rc ); } if (outgroup != MPI_GROUP_NULL) { rc = MPI_Group_free( &outgroup ); if (rc) { errs++; MTestPrintError( rc ); } } MTestFreeComm( &comm ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/group/grouptest2.c000644 001750 001750 00000014452 12342443662 022603 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* Test the group routines (some tested elsewere) MPI_Group_compare MPI_Group_excl MPI_Group_intersection MPI_Group_range_excl MPI_Group_rank MPI_Group_size MPI_Group_translate_ranks MPI_Group_union */ #include "mpi.h" #include /* stdlib.h Needed for malloc declaration */ #include int main( int argc, char **argv ) { int errs=0, toterr; MPI_Group basegroup; MPI_Group g1, g2, g3, g4, g5, g6, g7, g8, g9, g10; MPI_Group g3a, g3b; MPI_Comm comm, newcomm, splitcomm, dupcomm; int i, grp_rank, rank, grp_size, size, result; int nranks, *ranks, *ranks_out; int range[1][3]; int worldrank; MPI_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &worldrank ); comm = MPI_COMM_WORLD; MPI_Comm_group( comm, &basegroup ); MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); /* Get the basic information on this group */ MPI_Group_rank( basegroup, &grp_rank ); if (grp_rank != rank) { errs++; fprintf( stdout, "group rank %d != comm rank %d\n", grp_rank, rank ); } MPI_Group_size( basegroup, &grp_size ); if (grp_size != size) { errs++; fprintf( stdout, "group size %d != comm size %d\n", grp_size, size ); } /* Form a new communicator with inverted ranking */ MPI_Comm_split( comm, 0, size - rank, &newcomm ); MPI_Comm_group( newcomm, &g1 ); ranks = (int *)malloc( size * sizeof(int) ); ranks_out = (int *)malloc( size * sizeof(int) ); for (i=0; i #include #include "mpitest.h" /* * This program tests that MPI_Comm_create applies to intercommunicators; * this is an extension added in MPI-2 */ int TestIntercomm( MPI_Comm ); int main( int argc, char *argv[] ) { int errs = 0; int size, isLeft, wrank; MPI_Comm intercomm, newcomm; MPI_Group oldgroup, newgroup; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); if (size < 4) { printf( "This test requires at least 4 processes\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); while (MTestGetIntercomm( &intercomm, &isLeft, 2 )) { int ranks[10], nranks, result; if (intercomm == MPI_COMM_NULL) continue; MPI_Comm_group( intercomm, &oldgroup ); ranks[0] = 0; nranks = 1; MTestPrintfMsg( 1, "Creating a new intercomm 0-0\n" ); MPI_Group_incl( oldgroup, nranks, ranks, &newgroup ); MPI_Comm_create( intercomm, newgroup, &newcomm ); /* Make sure that the new communicator has the appropriate pieces */ if (newcomm != MPI_COMM_NULL) { int new_rsize, new_size, flag, commok = 1; MPI_Comm_set_name( newcomm, (char*)"Single rank in each group" ); MPI_Comm_test_inter( intercomm, &flag ); if (!flag) { errs++; printf( "[%d] Output communicator is not an intercomm\n", wrank ); commok = 0; } MPI_Comm_remote_size( newcomm, &new_rsize ); MPI_Comm_size( newcomm, &new_size ); /* The new communicator has 1 process in each group */ if (new_rsize != 1) { errs++; printf( "[%d] Remote size is %d, should be one\n", wrank, new_rsize ); commok = 0; } if (new_size != 1) { errs++; printf( "[%d] Local size is %d, should be one\n", wrank, new_size ); commok = 0; } /* ... more to do */ if (commok) { errs += TestIntercomm( newcomm ); } } MPI_Group_free( &newgroup ); if (newcomm != MPI_COMM_NULL) { MPI_Comm_free( &newcomm ); } /* Now, do a sort of dup, using the original group */ MTestPrintfMsg( 1, "Creating a new intercomm (manual dup)\n" ); MPI_Comm_create( intercomm, oldgroup, &newcomm ); MPI_Comm_set_name( newcomm, (char*)"Dup of original" ); MTestPrintfMsg( 1, "Creating a new intercomm (manual dup (done))\n" ); MPI_Comm_compare( intercomm, newcomm, &result ); MTestPrintfMsg( 1, "Result of comm/intercomm compare is %d\n", result ); if (result != MPI_CONGRUENT) { const char *rname=0; errs++; switch (result) { case MPI_IDENT: rname = "IDENT"; break; case MPI_CONGRUENT: rname = "CONGRUENT"; break; case MPI_SIMILAR: rname = "SIMILAR"; break; case MPI_UNEQUAL: rname = "UNEQUAL"; break; printf( "[%d] Expected MPI_CONGRUENT but saw %d (%s)", wrank, result, rname ); fflush(stdout); } } else { /* Try to communication between each member of intercomm */ errs += TestIntercomm( newcomm ); } if (newcomm != MPI_COMM_NULL) { MPI_Comm_free(&newcomm); } /* test that an empty group in either side of the intercomm results in * MPI_COMM_NULL for all members of the comm */ if (isLeft) { /* left side reuses oldgroup, our local group in intercomm */ MPI_Comm_create(intercomm, oldgroup, &newcomm); } else { /* right side passes MPI_GROUP_EMPTY */ MPI_Comm_create(intercomm, MPI_GROUP_EMPTY, &newcomm); } if (newcomm != MPI_COMM_NULL) { printf("[%d] expected MPI_COMM_NULL, but got a different communicator\n", wrank); fflush(stdout); errs++; } if (newcomm != MPI_COMM_NULL) { MPI_Comm_free(&newcomm); } MPI_Group_free( &oldgroup ); MPI_Comm_free( &intercomm ); } MTest_Finalize(errs); MPI_Finalize(); return 0; } int TestIntercomm( MPI_Comm comm ) { int local_size, remote_size, rank, **bufs, *bufmem, rbuf[2], j; int errs = 0, wrank, nsize; char commname[MPI_MAX_OBJECT_NAME+1]; MPI_Request *reqs; MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); MPI_Comm_size( comm, &local_size ); MPI_Comm_remote_size( comm, &remote_size ); MPI_Comm_rank( comm, &rank ); MPI_Comm_get_name( comm, commname, &nsize ); MTestPrintfMsg( 1, "Testing communication on intercomm '%s', remote_size=%d\n", commname, remote_size ); reqs = (MPI_Request *)malloc( remote_size * sizeof(MPI_Request) ); if (!reqs) { printf( "[%d] Unable to allocated %d requests for testing intercomm %s\n", wrank, remote_size, commname ); errs++; return errs; } bufs = (int **) malloc( remote_size * sizeof(int *) ); if (!bufs) { printf( "[%d] Unable to allocated %d int pointers for testing intercomm %s\n", wrank, remote_size, commname ); errs++; return errs; } bufmem = (int *) malloc( remote_size * 2 * sizeof(int) ); if (!bufmem) { printf( "[%d] Unable to allocated %d int data for testing intercomm %s\n", wrank, 2*remote_size, commname ); errs++; return errs; } /* Each process sends a message containing its own rank and the rank of the destination with a nonblocking send. Because we're using nonblocking sends, we need to use different buffers for each isend */ /* NOTE: the send buffer access restriction was relaxed in MPI-2.2, although it doesn't really hurt to keep separate buffers for our purposes */ for (j=0; j #include "mpitest.h" /* static char MTEST_Descrip[] = "Get the group of an intercommunicator"; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size, grank, gsize; int minsize = 2, isleft; MPI_Comm comm; MPI_Group group; MTest_Init( &argc, &argv ); /* The following illustrates the use of the routines to run through a selection of communicators and datatypes. Use subsets of these for tests that do not involve combinations of communicators, datatypes, and counts of datatypes */ while (MTestGetIntercomm( &comm, &isleft, minsize )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); MPI_Comm_group( comm, &group ); MPI_Group_rank( group, &grank ); MPI_Group_size( group, &gsize ); if (rank != grank) { errs++; fprintf( stderr, "Ranks of groups do not match %d != %d\n", rank, grank ); } if (size != gsize) { errs++; fprintf( stderr, "Sizes of groups do not match %d != %d\n", size, gsize ); } MPI_Group_free( &group ); MTestFreeComm( &comm ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/dupic.c000644 001750 001750 00000005370 12342443662 021367 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" int main( int argc, char *argv[] ) { int errs = 0; MPI_Comm comm, dupcomm, dupcomm2; MPI_Request rreq[2]; int count; int indicies[2]; int r1buf, r2buf, s1buf, s2buf; int rank, isLeft; MTest_Init( &argc, &argv ); while (MTestGetIntercomm( &comm, &isLeft, 2 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_dup( comm, &dupcomm ); /* Check that there are separate contexts. We do this by setting up nonblocking received on both communicators, and then sending to them. If the contexts are different, tests on the unsatisfied communicator should indicate no available message */ MPI_Comm_rank( comm, &rank ); if (rank == 0) { s1buf = 456; s2buf = 17; r1buf = r2buf = -1; /* These are send/receives to the process with rank zero in the other group (these are intercommunicators) */ MPI_Irecv( &r1buf, 1, MPI_INT, 0, 0, dupcomm, &rreq[0] ); MPI_Irecv( &r2buf, 1, MPI_INT, 0, 0, comm, &rreq[1] ); MPI_Send( &s2buf, 1, MPI_INT, 0, 0, comm ); MPI_Waitsome(2, rreq, &count, indicies, MPI_STATUSES_IGNORE); if (count != 1 || indicies[0] != 1) { /* The only valid return is that exactly one message has been received */ errs++; if (count == 1 && indicies[0] != 1) { printf( "Error in context values for intercomm\n" ); } else if (count == 2) { printf( "Error: two messages received!\n" ); } else { int i; printf( "Error: count = %d", count ); for (i=0; i #include "mpitest.h" /* * This program tests the allocation (and deallocation) of contexts. * */ int main( int argc, char **argv ) { int errs = 0; int i, j, err; MPI_Comm newcomm1, newcomm2[200]; MTest_Init( &argc, &argv ); /* Get a separate communicator to duplicate */ MPI_Comm_dup( MPI_COMM_WORLD, &newcomm1 ); MPI_Errhandler_set( newcomm1, MPI_ERRORS_RETURN ); /* Allocate many communicators in batches, then free them */ for (i=0; i<1000; i++) { for (j=0; j<200; j++) { err = MPI_Comm_dup( newcomm1, &newcomm2[j] ); if (err) { errs++; if (errs < 10) { fprintf( stderr, "Failed to duplicate communicator for (%d,%d)\n", i, j ); MTestPrintError( err ); } } } for (j=0; j<200; j++) { err = MPI_Comm_free( &newcomm2[j] ); if (err) { errs++; if (errs < 10) { fprintf( stderr, "Failed to free %d,%d\n", i, j ); MTestPrintError( err ); } } } } err = MPI_Comm_free( &newcomm1 ); if (err) { errs++; fprintf( stderr, "Failed to free newcomm1\n" ); MTestPrintError( err ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/icm.c000644 001750 001750 00000005300 12342443662 021024 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2004 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test intercomm merge, including the choice of the high value"; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size, rsize; int nsize, nrank; int minsize = 2; int isLeft; MPI_Comm comm, comm1, comm2, comm3, comm4; MTest_Init( &argc, &argv ); /* The following illustrates the use of the routines to run through a selection of communicators and datatypes. Use subsets of these for tests that do not involve combinations of communicators, datatypes, and counts of datatypes */ while (MTestGetIntercomm( &comm, &isLeft, minsize )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_remote_size( comm, &rsize ); MPI_Comm_size( comm, &size ); /* Try building intercomms */ MPI_Intercomm_merge( comm, isLeft, &comm1 ); /* Check the size and ranks */ MPI_Comm_size( comm1, &nsize ); MPI_Comm_rank( comm1, &nrank ); if (nsize != size + rsize) { errs++; printf( "(1) Comm size is %d but should be %d\n", nsize, size + rsize ); if (isLeft) { /* The left processes should be high */ if (nrank != rsize + rank) { errs++; printf( "(1) rank for high process is %d should be %d\n", nrank, rsize + rank ); } } else { /* The right processes should be low */ if (nrank != rank) { errs++; printf( "(1) rank for low process is %d should be %d\n", nrank, rank ); } } } MPI_Intercomm_merge( comm, !isLeft, &comm2 ); /* Check the size and ranks */ MPI_Comm_size( comm1, &nsize ); MPI_Comm_rank( comm1, &nrank ); if (nsize != size + rsize) { errs++; printf( "(2) Comm size is %d but should be %d\n", nsize, size + rsize ); if (!isLeft) { /* The right processes should be high */ if (nrank != rsize + rank) { errs++; printf( "(2) rank for high process is %d should be %d\n", nrank, rsize + rank ); } } else { /* The left processes should be low */ if (nrank != rank) { errs++; printf( "(2) rank for low process is %d should be %d\n", nrank, rank ); } } } MPI_Intercomm_merge( comm, 0, &comm3 ); MPI_Intercomm_merge( comm, 1, &comm4 ); MPI_Comm_free( &comm1 ); MPI_Comm_free( &comm2 ); MPI_Comm_free( &comm3 ); MPI_Comm_free( &comm4 ); MTestFreeComm( &comm ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/comm_idup.c000644 001750 001750 00000011540 12342443661 022232 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2012 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include #include "mpi.h" #include "mpitest.h" /* This is a temporary #ifdef to control whether we test this functionality. A * configure-test or similar would be better. Eventually the MPI-3 standard * will be released and this can be gated on a MPI_VERSION check */ #if !defined(USE_STRICT_MPI) && defined(MPICH) #define TEST_IDUP 1 #endif /* assert-like macro that bumps the err count and emits a message */ #define check(x_) \ do { \ if (!(x_)) { \ ++errs; \ if (errs < 10) { \ fprintf(stderr, "check failed: (%s), line %d\n", #x_, __LINE__); \ } \ } \ } while (0) int main(int argc, char **argv) { int errs = 0; int i; int rank, size, lrank, lsize, rsize; int buf[2]; MPI_Comm newcomm, ic, localcomm, stagger_comm; MPI_Request rreq; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); if (size < 2) { printf("this test requires at least 2 processes\n"); MPI_Abort(MPI_COMM_WORLD, 1); exit(1); } #ifdef TEST_IDUP /* test plan: make rank 0 wait in a blocking recv until all other processes * have posted their MPI_Comm_idup ops, then post last. Should ensure that * idup doesn't block on the non-zero ranks, otherwise we'll get a deadlock. */ if (rank == 0) { for (i = 1; i < size; ++i) { buf[0] = 0x01234567; buf[1] = 0x89abcdef; MPI_Recv(buf, 2, MPI_INT, i, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE); } MPI_Comm_idup(MPI_COMM_WORLD, &newcomm, &rreq); MPI_Wait(&rreq, MPI_STATUS_IGNORE); } else { MPI_Comm_idup(MPI_COMM_WORLD, &newcomm, &rreq); buf[0] = rank; buf[1] = size + rank; MPI_Ssend(buf, 2, MPI_INT, 0, 0, MPI_COMM_WORLD); MPI_Wait(&rreq, MPI_STATUS_IGNORE); } /* do some communication to make sure that newcomm works */ buf[0] = rank; buf[1] = 0xfeedface; MPI_Allreduce(&buf[0], &buf[1], 1, MPI_INT, MPI_SUM, newcomm); check(buf[1] == (size * (size-1) / 2)); MPI_Comm_free(&newcomm); /* now construct an intercomm and make sure we can dup that too */ MPI_Comm_split(MPI_COMM_WORLD, rank % 2, rank, &localcomm); MPI_Intercomm_create(localcomm, 0, MPI_COMM_WORLD, (rank == 0 ? 1 : 0), 1234, &ic); /* Create a communicator on just the "right hand group" of the intercomm in * order to make it more likely to catch bugs related to incorrectly * swapping the context_id and recvcontext_id in the idup code. */ stagger_comm = MPI_COMM_NULL; if (rank % 2) { MPI_Comm_dup(localcomm, &stagger_comm); } MPI_Comm_rank(ic, &lrank); MPI_Comm_size(ic, &lsize); MPI_Comm_remote_size(ic, &rsize); /* Similar to above pattern, but all non-local-rank-0 processes send to * remote rank 0. Both sides participate in this way. */ if (lrank == 0) { for (i = 1; i < rsize; ++i) { buf[0] = 0x01234567; buf[1] = 0x89abcdef; MPI_Recv(buf, 2, MPI_INT, i, 0, ic, MPI_STATUS_IGNORE); } MPI_Comm_idup(ic, &newcomm, &rreq); MPI_Wait(&rreq, MPI_STATUS_IGNORE); } else { MPI_Comm_idup(ic, &newcomm, &rreq); buf[0] = lrank; buf[1] = lsize + lrank; MPI_Ssend(buf, 2, MPI_INT, 0, 0, ic); MPI_Wait(&rreq, MPI_STATUS_IGNORE); } /* do some communication to make sure that newcomm works */ buf[0] = lrank; buf[1] = 0xfeedface; MPI_Allreduce(&buf[0], &buf[1], 1, MPI_INT, MPI_SUM, newcomm); check(buf[1] == (rsize * (rsize-1) / 2)); /* free this down here, not before idup, otherwise it will undo our * stagger_comm work */ MPI_Comm_free(&localcomm); if (stagger_comm != MPI_COMM_NULL) { MPI_Comm_free(&stagger_comm); } MPI_Comm_free(&newcomm); MPI_Comm_free(&ic); #endif /* TEST_IDUP */ MPI_Reduce((rank == 0 ? MPI_IN_PLACE : &errs), &errs, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); if (rank == 0) { if (errs) { printf("found %d errors\n", errs); } else { printf(" No errors\n"); } } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/cmsplit.c000644 001750 001750 00000002211 12342443661 021724 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test comm split"; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size, color, srank; MPI_Comm comm, scomm; MTest_Init( &argc, &argv ); MPI_Comm_dup( MPI_COMM_WORLD, &comm ); MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); if (size < 4) { fprintf( stderr, "This test requires at least four processes." ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } color = MPI_UNDEFINED; if (rank < 2) color = 1; MPI_Comm_split( comm, color, size - rank, &scomm ); if (rank < 2) { /* Check that the ranks are ordered correctly */ MPI_Comm_rank( scomm, &srank ); if (srank != 1 - rank) { errs++; } MPI_Comm_free( &scomm ); } else { if (scomm != MPI_COMM_NULL) { errs++; } } MPI_Comm_free( &comm ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/testlist000644 001750 001750 00000001545 12342443666 021721 0ustar00cici000000 000000 dup 2 #needs MPI_Intercomm_create #dupic 4 #works, but needs MPI_Comm_set_name commcreate1 8 #needs MPI_Comm_set_name and MPI_Intercomm_create #commname 4 #ic1 4 # ic2 needs an unusually large number of processes (>= 33) #ic2 33 #icgroup 8 #icm 8 #icsplit 8 #iccreate 8 ctxalloc 2 timeLimit=300 ctxsplit 4 timeLimit=300 cmfree 4 cmsplit 4 cmsplit2 12 #probe-intercomm 2 cmsplit_type 4 mpiversion=3.0 comm_create_group 4 mpiversion=3.0 comm_create_group 8 mpiversion=3.0 comm_group_half 2 mpiversion=3.0 comm_group_half 4 mpiversion=3.0 comm_group_half 8 mpiversion=3.0 comm_group_rand 2 mpiversion=3.0 comm_group_rand 4 mpiversion=3.0 comm_group_rand 8 mpiversion=3.0 comm_idup 2 mpiversion=3.0 comm_idup 4 mpiversion=3.0 comm_idup 9 mpiversion=3.0 dup_with_info 2 mpiversion=3.0 dup_with_info 4 mpiversion=3.0 dup_with_info 9 mpiversion=3.0 comm_info 6 mpiversion=3.0 SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/cmsplit2.c000644 001750 001750 00000012001 12342443661 022004 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2011 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* This test ensures that MPI_Comm_split breaks ties in key values by using the * original rank in the input communicator. This typically corresponds to * the difference between using a stable sort or using an unstable sort. * * It checks all sizes from 1..comm_size(world)-1, so this test does not need to * be run multiple times at process counts from a higher-level test driver. */ #include #include #include "mpi.h" #define ERRLIMIT (10) #define my_assert(cond_) \ do { \ if (!(cond_)) { \ if (errs < ERRLIMIT) \ printf("assertion \"%s\" failed\n", #cond_); \ ++errs; \ } \ } while (0) int main(int argc, char **argv) { int i, j, pos, modulus, cs, rank, size; int wrank, wsize; int newrank, newsize; int errs = 0; int key; int *oldranks = NULL; int *identity = NULL; int verbose = 0; MPI_Comm comm, splitcomm; MPI_Group wgroup, newgroup; MPI_Init(&argc, &argv); if (getenv("MPITEST_VERBOSE")) verbose = 1; MPI_Comm_rank(MPI_COMM_WORLD, &wrank); MPI_Comm_size(MPI_COMM_WORLD, &wsize); oldranks = malloc(wsize * sizeof(int)); identity = malloc(wsize * sizeof(int)); for (i = 0; i < wsize; ++i) { identity[i] = i; } for (cs = 1; cs <= wsize; ++cs) { /* yes, we are using comm_split to test comm_split, but this test is * mainly about ensuring that the stable sort behavior is correct, not * about whether the partitioning by color behavior is correct */ MPI_Comm_split(MPI_COMM_WORLD, (wrank < cs ? 0 : MPI_UNDEFINED), wrank, &comm); if (comm != MPI_COMM_NULL) { MPI_Comm_rank(comm, &rank); MPI_Comm_size(comm, &size); for (modulus = 1; modulus <= size; ++modulus) { /* Divide all ranks into one of "modulus" equivalence classes. Ranks in * output comm will be ordered first by class, then within the class by * rank in comm world. */ key = rank % modulus; /* all pass same color, variable keys */ MPI_Comm_split(comm, 5, key, &splitcomm); MPI_Comm_rank(splitcomm, &newrank); MPI_Comm_size(splitcomm, &newsize); my_assert(newsize == size); MPI_Comm_group(MPI_COMM_WORLD, &wgroup); MPI_Comm_group(splitcomm, &newgroup); int gsize; MPI_Group_size(newgroup, &gsize); MPI_Group_translate_ranks(newgroup, size, identity, wgroup, oldranks); MPI_Group_free(&wgroup); MPI_Group_free(&newgroup); if (splitcomm != MPI_COMM_NULL) MPI_Comm_free(&splitcomm); /* now check that comm_split broke any ties correctly */ if (rank == 0) { if (verbose) { /* debugging code that is useful when the test fails */ printf("modulus=%d oldranks={", modulus); for (i = 0; i < size - 1; ++i) { printf("%d,", oldranks[i]); } printf("%d} keys={", oldranks[i]); for (i = 0; i < size - 1; ++i) { printf("%d,", i % modulus); } printf("%d}\n", i % modulus); } pos = 0; for (i = 0; i < modulus; ++i) { /* there's probably a better way to write these loop bounds and * indices, but this is the first (correct) way that occurred to me */ for (j = 0; j < (size / modulus + (i < size % modulus ? 1 : 0)); ++j) { if (errs < ERRLIMIT && oldranks[pos] != i+modulus*j) { printf("size=%d i=%d j=%d modulus=%d pos=%d i+modulus*j=%d oldranks[pos]=%d\n", size, i, j, modulus, pos, i+modulus*j, oldranks[pos]); } my_assert(oldranks[pos] == i+modulus*j); ++pos; } } } } MPI_Comm_free(&comm); } } if (oldranks != NULL) free(oldranks); if (identity != NULL) free(identity); if (rank == 0) { if (errs) printf("found %d errors\n", errs); else printf(" No errors\n"); } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/dup.c000644 001750 001750 00000003535 12342443662 021054 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" int main( int argc, char **argv ) { int errs = 0; int rank, size, wrank, wsize, dest, a, b; MPI_Comm newcomm; MPI_Status status; MTest_Init( &argc, &argv ); /* Can we run comm dup at all? */ MPI_Comm_dup( MPI_COMM_WORLD, &newcomm ); /* Check basic properties */ MPI_Comm_size( MPI_COMM_WORLD, &wsize ); MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); MPI_Comm_size( newcomm, &size ); MPI_Comm_rank( newcomm, &rank ); if (size != wsize || rank != wrank) { errs++; fprintf( stderr, "Size (%d) or rank (%d) wrong\n", size, rank ); fflush( stderr ); } /* Can we communicate with this new communicator? */ if (rank == 0) { dest = size - 1; a = rank; b = -1; MPI_Sendrecv( &a, 1, MPI_INT, dest, 0, &b, 1, MPI_INT, dest, 0, newcomm, &status ); if (b != dest) { errs++; fprintf( stderr, "Received %d expected %d on %d\n", b, dest, rank ); fflush( stderr ); } if (status.MPI_SOURCE != dest) { errs++; fprintf( stderr, "Source not set correctly in status on %d\n", rank ); fflush( stderr ); } } else if (rank == size-1) { dest = 0; a = rank; b = -1; MPI_Sendrecv( &a, 1, MPI_INT, dest, 0, &b, 1, MPI_INT, dest, 0, newcomm, &status ); if (b != dest) { errs++; fprintf( stderr, "Received %d expected %d on %d\n", b, dest, rank ); fflush( stderr ); } if (status.MPI_SOURCE != dest) { errs++; fprintf( stderr, "Source not set correctly in status on %d\n", rank ); fflush( stderr ); } } MPI_Comm_free( &newcomm ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/cmfree.c000644 001750 001750 00000005545 12342443661 021527 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test that communicators have reference count semantics"; */ #define NELM 128 #define NCOMM 1020 int main( int argc, char *argv[] ) { int errs = 0; int rank, size, source, dest, i; MPI_Comm comm; MPI_Comm tmpComm[NCOMM]; MPI_Status status; MPI_Request req; int *buf=0; MTest_Init( &argc, &argv ); MPI_Comm_dup( MPI_COMM_WORLD, &comm ); /* This is similar to the datatype test, except that we post an irecv on a simple data buffer but use a rank-reordered communicator. In this case, an error in handling the reference count will most likely cause the program to hang, so this should be run only if (a) you are confident that the code is correct or (b) a timeout is set for mpiexec */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); if (size < 2) { fprintf( stderr, "This test requires at least two processes." ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } source = 0; dest = size - 1; if (rank == dest) { buf = (int *)malloc( NELM * sizeof(int) ); for (i=0; i #include #include "mpitest.h" #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif int main( int argc, char *argv[] ) { int errs = 0; MPI_Comm comm; int cnt, rlen; char name[MPI_MAX_OBJECT_NAME], nameout[MPI_MAX_OBJECT_NAME]; MTest_Init( &argc, &argv ); /* Check world and self firt */ nameout[0] = 0; MPI_Comm_get_name( MPI_COMM_WORLD, nameout, &rlen ); if (strcmp(nameout,"MPI_COMM_WORLD")) { errs++; printf( "Name of comm world is %s, should be MPI_COMM_WORLD\n", nameout ); } nameout[0] = 0; MPI_Comm_get_name( MPI_COMM_SELF, nameout, &rlen ); if (strcmp(nameout,"MPI_COMM_SELF")) { errs++; printf( "Name of comm self is %s, should be MPI_COMM_SELF\n", nameout ); } /* Now, handle other communicators, including world/self */ cnt = 0; while (MTestGetComm( &comm, 1 )) { if (comm == MPI_COMM_NULL) continue; sprintf( name, "comm-%d", cnt ); cnt++; MPI_Comm_set_name( comm, name ); nameout[0] = 0; MPI_Comm_get_name( comm, nameout, &rlen ); if (strcmp( name, nameout )) { errs++; printf( "Unexpected name, was %s but should be %s\n", nameout, name ); } MTestFreeComm( &comm ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/probe-intercomm.c000644 001750 001750 00000003744 12342443662 023370 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test MPI_Probe() for an intercomm"; */ #define MAX_DATA_LEN 100 int main( int argc, char *argv[] ) { int errs = 0, recvlen, isLeft; MPI_Status status; int rank, size; MPI_Comm intercomm; char buf[MAX_DATA_LEN]; const char *test_str = "test"; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); if (size < 2) { fprintf( stderr, "This test requires at least two processes." ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } while (MTestGetIntercomm( &intercomm, &isLeft, 2 )) { if (intercomm == MPI_COMM_NULL) continue; MPI_Comm_rank(intercomm, &rank); /* 0 ranks on each side communicate, everyone else does nothing */ if(rank == 0) { if (isLeft) { recvlen = -1; MPI_Probe(0, 0, intercomm, &status); MPI_Get_count(&status, MPI_CHAR, &recvlen); if (recvlen != (strlen(test_str) + 1)) { printf(" Error: recvlen (%d) != strlen(\"%s\")+1 (%d)\n", recvlen, test_str, (int)strlen(test_str) + 1); ++errs; } buf[0] = '\0'; MPI_Recv(buf, recvlen, MPI_CHAR, 0, 0, intercomm, &status); if (strcmp(test_str,buf)) { printf(" Error: strcmp(test_str,buf)!=0\n"); ++errs; } } else { strncpy(buf, test_str, 5); MPI_Send(buf, strlen(buf)+1, MPI_CHAR, 0, 0, intercomm); } } MTestFreeComm(&intercomm); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/comm_group_half.c000644 001750 001750 00000002140 12342443661 023413 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include /* USE_STRICT_MPI may be defined in mpitestconf.h */ #include "mpitestconf.h" int main(int argc, char **argv) { int rank, size; MPI_Group full_group, half_group; int range[1][3]; MPI_Comm __attribute__((unused)) comm; MPI_Init(NULL, NULL); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_group(MPI_COMM_WORLD, &full_group); range[0][0] = 0; range[0][1] = size / 2; range[0][2] = 1; MPI_Group_range_incl(full_group, 1, range, &half_group); #if !defined(USE_STRICT_MPI) && defined(MPICH) if (rank <= size / 2) { MPI_Comm_create_group(MPI_COMM_WORLD, half_group, 0, &comm); MPI_Barrier(comm); MPI_Comm_free(&comm); } #endif /* USE_STRICT_MPI */ MPI_Group_free(&half_group); MPI_Group_free(&full_group); if (rank == 0) printf(" No Errors\n"); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/comm_group_rand.c000644 001750 001750 00000003025 12342443661 023430 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include /* USE_STRICT_MPI may be defined in mpitestconf.h */ #include "mpitestconf.h" #define LOOPS 100 int main(int argc, char **argv) { int rank, size, i, j, count; MPI_Group full_group, sub_group; int *included, *ranks; MPI_Comm __attribute__((unused)) comm; MPI_Init(NULL, NULL); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); ranks = malloc(size * sizeof(int)); included = malloc(size * sizeof(int)); MPI_Comm_group(MPI_COMM_WORLD, &full_group); for (j = 0; j < LOOPS; j++) { srand(j); /* Deterministic seed */ count = 0; for (i = 0; i < size; i++) { if (rand() % 2) { /* randomly include a rank */ included[i] = 1; ranks[count++] = i; } else included[i] = 0; } MPI_Group_incl(full_group, count, ranks, &sub_group); #if !defined(USE_STRICT_MPI) && defined(MPICH) if (included[rank]) { MPI_Comm_create_group(MPI_COMM_WORLD, sub_group, 0, &comm); MPI_Barrier(comm); MPI_Comm_free(&comm); } #endif /* USE_STRICT_MPI */ MPI_Group_free(&sub_group); } MPI_Group_free(&full_group); if (rank == 0) printf(" No Errors\n"); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/comm_info.c000644 001750 001750 00000002637 12342443661 022233 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2012 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include "mpitest.h" #define VERBOSE 0 int main(int argc, char **argv) { int rank; MPI_Info info_in, info_out; int errors = 0, all_errors = 0; MPI_Comm comm; char __attribute__((unused)) invalid_key[] = "invalid_test_key"; char buf[MPI_MAX_INFO_VAL]; int flag; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Info_create(&info_in); MPI_Info_set(info_in, invalid_key, (char *) "true"); MPI_Comm_dup(MPI_COMM_WORLD, &comm); MPI_Comm_set_info(comm, info_in); MPI_Comm_get_info(comm, &info_out); MPI_Info_get(info_out, invalid_key, MPI_MAX_INFO_VAL, buf, &flag); #ifndef USE_STRICT_MPI /* Check if our invalid key was ignored. Note, this check's MPICH's * behavior, but this behavior may not be required for a standard * conforming MPI implementation. */ if (flag) { printf("%d: %s was not ignored\n", rank, invalid_key); errors++; } #endif MPI_Info_free(&info_in); MPI_Info_free(&info_out); MPI_Comm_free(&comm); MPI_Reduce(&errors, &all_errors, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); if (rank == 0 && all_errors == 0) printf(" No Errors\n"); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/commcreate1.c000644 001750 001750 00000010723 12342443661 022460 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2007 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* Check that Communicators can be created from various subsets of the processes in the communicator. */ void abortMsg( const char *, int ); int BuildComm( MPI_Comm, MPI_Group, const char [] ); void abortMsg( const char *str, int code ) { char msg[MPI_MAX_ERROR_STRING]; int class, resultLen; MPI_Error_class( code, &class ); MPI_Error_string( code, msg, &resultLen ); fprintf( stderr, "%s: errcode = %d, class = %d, msg = %s\n", str, code, class, msg ); MPI_Abort( MPI_COMM_WORLD, code ); exit(code); } int main( int argc, char *argv[] ) { MPI_Comm dupWorld; int wrank, wsize, gsize, err, errs = 0; int ranges[1][3]; MPI_Group wGroup, godd, ghigh, geven; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &wsize ); MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); /* Create some groups */ MPI_Comm_group( MPI_COMM_WORLD, &wGroup ); MTestPrintfMsg( 2, "Creating groups\n" ); ranges[0][0] = 2*(wsize/2)-1; ranges[0][1] = 1; ranges[0][2] = -2; err = MPI_Group_range_incl( wGroup, 1, ranges, &godd ); if (err) abortMsg( "Failed to create odd group: ", err ); err = MPI_Group_size( godd, &gsize ); if (err) abortMsg( "Failed to get size of odd group: ", err ); if (gsize != wsize/2) { fprintf( stderr, "Group godd size is %d should be %d\n", gsize, wsize/2 ); errs++; } ranges[0][0] = wsize/2+1; ranges[0][1] = wsize-1; ranges[0][2] = 1; err = MPI_Group_range_incl( wGroup, 1, ranges, &ghigh ); if (err) abortMsg( "Failed to create high group\n", err ); ranges[0][0] = 0; ranges[0][1] = wsize-1; ranges[0][2] = 2; err = MPI_Group_range_incl( wGroup, 1, ranges, &geven ); if (err) abortMsg( "Failed to create even group:", err ); MPI_Comm_dup( MPI_COMM_WORLD, &dupWorld ); MPI_Comm_set_name( dupWorld, (char*)"Dup of world" ); /* First, use the groups to create communicators from world and a dup of world */ errs += BuildComm( MPI_COMM_WORLD, ghigh, "ghigh" ); errs += BuildComm( MPI_COMM_WORLD, godd, "godd" ); errs += BuildComm( MPI_COMM_WORLD, geven, "geven" ); errs += BuildComm( dupWorld, ghigh, "ghigh" ); errs += BuildComm( dupWorld, godd, "godd" ); errs += BuildComm( dupWorld, geven, "geven" ); #if MTEST_HAVE_MIN_MPI_VERSION(2,2) /* check that we can create multiple communicators from a single collective * call to MPI_Comm_create as long as the groups are all disjoint */ errs += BuildComm( MPI_COMM_WORLD, (wrank % 2 ? godd : geven), "godd+geven" ); errs += BuildComm( dupWorld, (wrank % 2 ? godd : geven), "godd+geven" ); errs += BuildComm( MPI_COMM_WORLD, MPI_GROUP_EMPTY, "MPI_GROUP_EMPTY" ); errs += BuildComm( dupWorld, MPI_GROUP_EMPTY, "MPI_GROUP_EMPTY" ); #endif MPI_Comm_free( &dupWorld ); MPI_Group_free( &ghigh ); MPI_Group_free( &godd ); MPI_Group_free( &geven ); MPI_Group_free( &wGroup ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } int BuildComm( MPI_Comm oldcomm, MPI_Group group, const char gname[] ) { MPI_Comm newcomm; int grank, gsize, rank, size, errs = 0; char cname[MPI_MAX_OBJECT_NAME+1]; int cnamelen; MPI_Group_rank( group, &grank ); MPI_Group_size( group, &gsize ); MPI_Comm_get_name( oldcomm, cname, &cnamelen ); MTestPrintfMsg( 2, "Testing comm %s from %s\n", cname, gname ); MPI_Comm_create( oldcomm, group, &newcomm ); if (newcomm == MPI_COMM_NULL && grank != MPI_UNDEFINED) { errs ++; fprintf( stderr, "newcomm is null but process is in group\n" ); } if (newcomm != MPI_COMM_NULL && grank == MPI_UNDEFINED) { errs ++; fprintf( stderr, "newcomm is not null but process is not in group\n" ); } if (newcomm != MPI_COMM_NULL && grank != MPI_UNDEFINED) { MPI_Comm_rank( newcomm, &rank ); if (rank != grank) { errs ++; fprintf( stderr, "Rank is %d should be %d in comm from %s\n", rank, grank, gname ); } MPI_Comm_size( newcomm, &size ); if (size != gsize) { errs++; fprintf( stderr, "Size is %d should be %d in comm from %s\n", size, gsize, gname ); } MPI_Comm_free( &newcomm ); MTestPrintfMsg( 2, "Done testing comm %s from %s\n", cname, gname ); } return errs; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/comm_create_group.c000644 001750 001750 00000003051 12342443661 023746 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2011 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" /* USE_STRICT_MPI may be defined in mpitestconf.h */ #include "mpitestconf.h" #include #include #include #include int main(int argc, char *argv[]) { int size, rank, i, *excl; MPI_Group world_group, even_group; MPI_Comm __attribute__((unused)) even_comm; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (size % 2) { fprintf(stderr, "this program requires a multiple of 2 number of processes\n"); MPI_Abort(MPI_COMM_WORLD, 1); exit(1); } excl = malloc((size / 2) * sizeof(int)); assert(excl); /* exclude the odd ranks */ for (i = 0; i < size / 2; i++) excl[i] = (2 * i) + 1; /* Create some groups */ MPI_Comm_group(MPI_COMM_WORLD, &world_group); MPI_Group_excl(world_group, size / 2, excl, &even_group); MPI_Group_free(&world_group); #if !defined(USE_STRICT_MPI) && defined(MPICH) if (rank % 2 == 0) { /* Even processes create a group for themselves */ MPI_Comm_create_group(MPI_COMM_WORLD, even_group, 0, &even_comm); MPI_Barrier(even_comm); MPI_Comm_free(&even_comm); } #endif /* USE_STRICT_MPI */ MPI_Group_free(&even_group); MPI_Barrier(MPI_COMM_WORLD); if (rank == 0) printf(" No errors\n"); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/icsplit.c000644 001750 001750 00000013156 12342443662 021733 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2007 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* * This program tests that MPI_Comm_split applies to intercommunicators; * this is an extension added in MPI-2 */ int TestIntercomm( MPI_Comm ); int main( int argc, char *argv[] ) { int errs = 0; int size, isLeft; MPI_Comm intercomm, newcomm; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); if (size < 4) { printf( "This test requires at least 4 processes\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } while (MTestGetIntercomm( &intercomm, &isLeft, 2 )) { int key, color; if (intercomm == MPI_COMM_NULL) continue; /* Split this intercomm. The new intercomms contain the processes that had odd (resp even) rank in their local group in the original intercomm */ MTestPrintfMsg( 1, "Created intercomm %s\n", MTestGetIntercommName() ); MPI_Comm_rank( intercomm, &key ); color = (key % 2); MPI_Comm_split( intercomm, color, key, &newcomm ); /* Make sure that the new communicator has the appropriate pieces */ if (newcomm != MPI_COMM_NULL) { int orig_rsize, orig_size, new_rsize, new_size; int predicted_size, flag, commok=1; MPI_Comm_test_inter( intercomm, &flag ); if (!flag) { errs++; printf( "Output communicator is not an intercomm\n" ); commok = 0; } MPI_Comm_remote_size( intercomm, &orig_rsize ); MPI_Comm_remote_size( newcomm, &new_rsize ); MPI_Comm_size( intercomm, &orig_size ); MPI_Comm_size( newcomm, &new_size ); /* The local size is 1/2 the original size, +1 if the size was odd and the color was even. More precisely, let n be the orig_size. Then color 0 color 1 orig size even n/2 n/2 orig size odd (n+1)/2 n/2 However, since these are integer valued, if n is even, then (n+1)/2 = n/2, so this table is much simpler: color 0 color 1 orig size even (n+1)/2 n/2 orig size odd (n+1)/2 n/2 */ predicted_size = (orig_size + !color) / 2; if (predicted_size != new_size) { errs++; printf( "Predicted size = %d but found %d for %s (%d,%d)\n", predicted_size, new_size, MTestGetIntercommName(), orig_size, orig_rsize ); commok = 0; } predicted_size = (orig_rsize + !color) / 2; if (predicted_size != new_rsize) { errs++; printf( "Predicted remote size = %d but found %d for %s (%d,%d)\n", predicted_size, new_rsize, MTestGetIntercommName(), orig_size, orig_rsize ); commok = 0; } /* ... more to do */ if (commok) { errs += TestIntercomm( newcomm ); } } else { int orig_rsize; /* If the newcomm is null, then this means that remote group for this color is of size zero (since all processes in this test have been given colors other than MPI_UNDEFINED). Confirm that here */ /* FIXME: ToDo */ MPI_Comm_remote_size( intercomm, &orig_rsize ); if (orig_rsize == 1) { if (color == 0) { errs++; printf( "Returned null intercomm when non-null expected\n" ); } } } if (newcomm != MPI_COMM_NULL) MPI_Comm_free( &newcomm ); MPI_Comm_free( &intercomm ); } MTest_Finalize(errs); MPI_Finalize(); return 0; } /* FIXME: This is copied from iccreate. It should be in one place */ int TestIntercomm( MPI_Comm comm ) { int local_size, remote_size, rank, **bufs, *bufmem, rbuf[2], j; int errs = 0, wrank, nsize; char commname[MPI_MAX_OBJECT_NAME+1]; MPI_Request *reqs; MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); MPI_Comm_size( comm, &local_size ); MPI_Comm_remote_size( comm, &remote_size ); MPI_Comm_rank( comm, &rank ); MPI_Comm_get_name( comm, commname, &nsize ); MTestPrintfMsg( 1, "Testing communication on intercomm %s\n", commname ); reqs = (MPI_Request *)malloc( remote_size * sizeof(MPI_Request) ); if (!reqs) { printf( "[%d] Unable to allocated %d requests for testing intercomm %s\n", wrank, remote_size, commname ); errs++; return errs; } bufs = (int **) malloc( remote_size * sizeof(int *) ); if (!bufs) { printf( "[%d] Unable to allocated %d int pointers for testing intercomm %s\n", wrank, remote_size, commname ); errs++; return errs; } bufmem = (int *) malloc( remote_size * 2 * sizeof(int) ); if (!bufmem) { printf( "[%d] Unable to allocated %d int data for testing intercomm %s\n", wrank, 2*remote_size, commname ); errs++; return errs; } /* Each process sends a message containing its own rank and the rank of the destination with a nonblocking send. Because we're using nonblocking sends, we need to use different buffers for each isend */ for (j=0; j #include /* FIXME: This test only checks that the MPI_Comm_split_type routine doesn't fail. It does not check for correct behavior */ int main(int argc, char *argv[]) { int rank, size, verbose=0; int wrank; MPI_Comm comm; MPI_Init(&argc, &argv); if (getenv("MPITEST_VERBOSE")) verbose = 1; MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); /* Check to see if MPI_COMM_TYPE_SHARED works correctly */ MPI_Comm_split_type(MPI_COMM_WORLD, MPI_COMM_TYPE_SHARED, 0, MPI_INFO_NULL, &comm); if (comm == MPI_COMM_NULL) printf("Expected a non-null communicator, but got MPI_COMM_NULL\n"); else { MPI_Comm_rank(comm, &rank); MPI_Comm_size(comm, &size); if (rank == 0 && verbose) printf("Created subcommunicator of size %d\n", size); MPI_Comm_free(&comm); } /* Check to see if MPI_UNDEFINED is respected */ MPI_Comm_split_type(MPI_COMM_WORLD, (wrank % 2 == 0) ? MPI_COMM_TYPE_SHARED : MPI_UNDEFINED, 0, MPI_INFO_NULL, &comm); if ((wrank % 2) && (comm != MPI_COMM_NULL)) printf("Expected MPI_COMM_NULL, but did not get one\n"); if (wrank % 2 == 0) { if (comm == MPI_COMM_NULL) printf("Expected a non-null communicator, but got MPI_COMM_NULL\n"); else { MPI_Comm_rank(comm, &rank); MPI_Comm_size(comm, &size); if (rank == 0 && verbose) printf("Created subcommunicator of size %d\n", size); MPI_Comm_free(&comm); } } /* Use wrank because Comm_split_type may return more than one communicator across the job, and if so, each will have a rank 0 entry. Test output rules are for a single process to write the successful test (No Errors) output. */ if (wrank == 0) printf(" No errors\n"); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/dup_with_info.c000644 001750 001750 00000006004 12342443662 023114 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2012 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" int run_tests(MPI_Comm comm); int run_tests(MPI_Comm comm) { int rank, size, wrank, wsize, dest, a, b, errs = 0; MPI_Status status; /* Check basic properties */ MPI_Comm_size(MPI_COMM_WORLD, &wsize); MPI_Comm_rank(MPI_COMM_WORLD, &wrank); MPI_Comm_size(comm, &size); MPI_Comm_rank(comm, &rank); if (size != wsize || rank != wrank) { errs++; fprintf(stderr, "Size (%d) or rank (%d) wrong\n", size, rank); fflush(stderr); } MPI_Barrier(comm); /* Can we communicate with this new communicator? */ if (rank == 0) { dest = size - 1; a = rank; b = -1; MPI_Sendrecv(&a, 1, MPI_INT, dest, 0, &b, 1, MPI_INT, dest, 0, comm, &status); if (b != dest) { errs++; fprintf(stderr, "Received %d expected %d on %d\n", b, dest, rank); fflush(stderr); } if (status.MPI_SOURCE != dest) { errs++; fprintf(stderr, "Source not set correctly in status on %d\n", rank); fflush(stderr); } } else if (rank == size - 1) { dest = 0; a = rank; b = -1; MPI_Sendrecv(&a, 1, MPI_INT, dest, 0, &b, 1, MPI_INT, dest, 0, comm, &status); if (b != dest) { errs++; fprintf(stderr, "Received %d expected %d on %d\n", b, dest, rank); fflush(stderr); } if (status.MPI_SOURCE != dest) { errs++; fprintf(stderr, "Source not set correctly in status on %d\n", rank); fflush(stderr); } } MPI_Barrier(comm); return errs; } int main(int argc, char **argv) { int total_errs = 0; MPI_Comm newcomm; MPI_Info info; MTest_Init(&argc, &argv); /* Dup with no info */ MPI_Comm_dup_with_info(MPI_COMM_WORLD, MPI_INFO_NULL, &newcomm); total_errs += run_tests(newcomm); MPI_Comm_free(&newcomm); /* Dup with info keys */ MPI_Info_create(&info); MPI_Info_set(info, (char *) "host", (char *) "myhost.myorg.org"); MPI_Info_set(info, (char *) "file", (char *) "runfile.txt"); MPI_Info_set(info, (char *) "soft", (char *) "2:1000:4,3:1000:7"); MPI_Comm_dup_with_info(MPI_COMM_WORLD, info, &newcomm); total_errs += run_tests(newcomm); MPI_Info_free(&info); MPI_Comm_free(&newcomm); /* Dup with deleted info keys */ MPI_Info_create(&info); MPI_Info_set(info, (char *) "host", (char *) "myhost.myorg.org"); MPI_Info_set(info, (char *) "file", (char *) "runfile.txt"); MPI_Info_set(info, (char *) "soft", (char *) "2:1000:4,3:1000:7"); MPI_Comm_dup_with_info(MPI_COMM_WORLD, info, &newcomm); MPI_Info_free(&info); total_errs += run_tests(newcomm); MPI_Comm_free(&newcomm); MTest_Finalize(total_errs); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/ctxsplit.c000644 001750 001750 00000003604 12342443661 022132 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include #include "mpitest.h" /* * This check is intended to fail if there is a leak of context ids. * Because this is trying to exhaust the number of context ids, it needs * to run for a longer time than many tests. The for loop uses 100,000 * iterations, which is adequate for MPICH (with only about 1k context ids * available). */ int main(int argc, char** argv) { int i=0; int randval; int rank; int errs = 0; MPI_Comm newcomm; double startTime; int nLoop = 100000; MTest_Init(&argc,&argv); for (i=1; i 0) { rate = i / rate; MTestPrintfMsg( 10, "After %d (%f)\n", i, rate ); } else { MTestPrintfMsg( 10, "After %d\n", i ); } } /* FIXME: Explain the rationale behind rand in this test */ randval=rand(); if (randval%(rank+2) == 0) { MPI_Comm_split(MPI_COMM_WORLD,1,rank,&newcomm); MPI_Comm_free( &newcomm ); } else { MPI_Comm_split(MPI_COMM_WORLD,MPI_UNDEFINED,rank,&newcomm); if (newcomm != MPI_COMM_NULL) { errs++; printf( "Created a non-null communicator with MPI_UNDEFINED\n" ); } } } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/ic1.c000644 001750 001750 00000002573 12342443662 020741 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* * A simple test of the intercomm create routine, with a communication test */ #include "mpi.h" #include #include "mpitest.h" int main( int argc, char *argv[] ) { MPI_Comm intercomm; int remote_rank, rank, size, errs = 0; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); if (size < 2) { printf( "Size must be at least 2\n" ); MPI_Abort( MPI_COMM_WORLD, 0 ); exit(0); } MPI_Comm_rank( MPI_COMM_WORLD, &rank ); /* Make an intercomm of the first two elements of comm_world */ if (rank < 2) { int lrank = rank, rrank = -1; MPI_Status status; remote_rank = 1 - rank; MPI_Intercomm_create( MPI_COMM_SELF, 0, MPI_COMM_WORLD, remote_rank, 27, &intercomm ); /* Now, communicate between them */ MPI_Sendrecv( &lrank, 1, MPI_INT, 0, 13, &rrank, 1, MPI_INT, 0, 13, intercomm, &status ); if (rrank != remote_rank) { errs++; printf( "%d Expected %d but received %d\n", rank, remote_rank, rrank ); } MPI_Comm_free( &intercomm ); } /* The next test should create an intercomm with groups of different sizes FIXME */ MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/ic2.c000644 001750 001750 00000004216 12342443662 020736 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2012 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* regression test for ticket #1574 * * Based on test code from N. Radclif @ Cray. */ #include #include #include int main(int argc, char **argv) { MPI_Comm c0, c1, ic; MPI_Group g0, g1, gworld; int a, b, c, d; int rank, size, remote_leader, tag; int ranks[2]; int errs = 0; tag = 5; c0 = c1 = ic = MPI_COMM_NULL; g0 = g1 = gworld = MPI_GROUP_NULL; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); if (size < 33) { printf("ERROR: this test requires at least 33 processes\n"); MPI_Abort(MPI_COMM_WORLD, 1); exit(1); } /* group of c0 * NOTE: a>=32 is essential for exercising the loop bounds bug from tt#1574 */ a = 32; b = 24; /* group of c1 */ c = 25; d = 26; MPI_Comm_group(MPI_COMM_WORLD, &gworld); ranks[0] = a; ranks[1] = b; MPI_Group_incl(gworld, 2, ranks, &g0); MPI_Comm_create(MPI_COMM_WORLD, g0, &c0); ranks[0] = c; ranks[1] = d; MPI_Group_incl(gworld, 2, ranks, &g1); MPI_Comm_create(MPI_COMM_WORLD, g1, &c1); if (rank == a || rank == b) { remote_leader = c; MPI_Intercomm_create(c0, 0, MPI_COMM_WORLD, remote_leader, tag, &ic); } else if (rank == c || rank == d) { remote_leader = a; MPI_Intercomm_create(c1, 0, MPI_COMM_WORLD, remote_leader, tag, &ic); } MPI_Group_free(&g0); MPI_Group_free(&g1); MPI_Group_free(&gworld); if (c0 != MPI_COMM_NULL) MPI_Comm_free(&c0); if (c1 != MPI_COMM_NULL) MPI_Comm_free(&c1); if (ic != MPI_COMM_NULL) MPI_Comm_free(&ic); MPI_Reduce((rank == 0 ? MPI_IN_PLACE : &errs), &errs, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); if (rank == 0) { if (errs) { printf("found %d errors\n", errs); } else { printf(" No errors\n"); } } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/comm/CMakeLists.txt000644 001750 001750 00000007456 12342443654 022667 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include/") add_executable(cmfree cmfree.c) add_executable(cmsplit2 cmsplit2.c) add_executable(cmsplit cmsplit.c) add_executable(cmsplit_type cmsplit_type.c) add_executable(commcreate1 commcreate1.c) add_executable(comm_create_group comm_create_group.c) add_executable(comm_group_half comm_group_half.c) add_executable(comm_group_rand comm_group_rand.c) # add_executable(comm_idup comm_idup.c) add_executable(comm_info comm_info.c) # add_executable(commname commname.c) add_executable(ctxalloc ctxalloc.c) add_executable(ctxsplit ctxsplit.c) add_executable(dup dup.c) # add_executable(dupic dupic.c) add_executable(dup_with_info dup_with_info.c) # add_executable(ic1 ic1.c) # add_executable(ic2 ic2.c) # add_executable(iccreate iccreate.c) # add_executable(icgroup icgroup.c) # add_executable(icm icm.c) # add_executable(icsplit icsplit.c) # add_executable(probe-intercomm probe-intercomm.c) target_link_libraries(cmfree simgrid mtest_c) target_link_libraries(cmsplit2 simgrid mtest_c) target_link_libraries(cmsplit simgrid mtest_c) target_link_libraries(cmsplit_type simgrid mtest_c) target_link_libraries(commcreate1 simgrid mtest_c) target_link_libraries(comm_create_group simgrid mtest_c) target_link_libraries(comm_group_half simgrid mtest_c) target_link_libraries(comm_group_rand simgrid mtest_c) # target_link_libraries(comm_idup simgrid mtest_c) target_link_libraries(comm_info simgrid mtest_c) # target_link_libraries(commname simgrid mtest_c) target_link_libraries(ctxalloc simgrid mtest_c) target_link_libraries(ctxsplit simgrid mtest_c) target_link_libraries(dup simgrid mtest_c) # target_link_libraries(dupic simgrid mtest_c) target_link_libraries(dup_with_info simgrid mtest_c) # target_link_libraries(ic1 simgrid mtest_c) # target_link_libraries(ic2 simgrid mtest_c) # target_link_libraries(iccreate simgrid mtest_c) # target_link_libraries(icgroup simgrid mtest_c) # target_link_libraries(icm simgrid mtest_c) # target_link_libraries(icsplit simgrid mtest_c) # target_link_libraries(probe-intercomm simgrid mtest_c) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/cmfree.c ${CMAKE_CURRENT_SOURCE_DIR}/cmsplit2.c ${CMAKE_CURRENT_SOURCE_DIR}/cmsplit.c ${CMAKE_CURRENT_SOURCE_DIR}/cmsplit_type.c ${CMAKE_CURRENT_SOURCE_DIR}/commcreate1.c ${CMAKE_CURRENT_SOURCE_DIR}/comm_create_group.c ${CMAKE_CURRENT_SOURCE_DIR}/comm_group_half.c ${CMAKE_CURRENT_SOURCE_DIR}/comm_group_rand.c ${CMAKE_CURRENT_SOURCE_DIR}/comm_idup.c ${CMAKE_CURRENT_SOURCE_DIR}/comm_info.c ${CMAKE_CURRENT_SOURCE_DIR}/commname.c ${CMAKE_CURRENT_SOURCE_DIR}/ctxalloc.c ${CMAKE_CURRENT_SOURCE_DIR}/ctxsplit.c ${CMAKE_CURRENT_SOURCE_DIR}/dup.c ${CMAKE_CURRENT_SOURCE_DIR}/dupic.c ${CMAKE_CURRENT_SOURCE_DIR}/dup_with_info.c ${CMAKE_CURRENT_SOURCE_DIR}/ic1.c ${CMAKE_CURRENT_SOURCE_DIR}/ic2.c ${CMAKE_CURRENT_SOURCE_DIR}/iccreate.c ${CMAKE_CURRENT_SOURCE_DIR}/icgroup.c ${CMAKE_CURRENT_SOURCE_DIR}/icm.c ${CMAKE_CURRENT_SOURCE_DIR}/icsplit.c ${CMAKE_CURRENT_SOURCE_DIR}/probe-intercomm.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/000755 001750 001750 00000000000 12342443666 017561 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/util/000755 001750 001750 00000000000 12342443666 020536 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/util/mtestf90.f90000644 001750 001750 00000006656 12342443666 022546 0ustar00cici000000 000000 ! This file created from test/mpi/f77/util/mtestf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! subroutine MTest_Init( ierr ) ! Place the include first so that we can automatically create a ! Fortran 90 version that uses the mpi module instead. If ! the module is in a different place, the compiler can complain ! about out-of-order statements use mpi integer ierr logical flag logical dbgflag integer wrank common /mtest/ dbgflag, wrank call MPI_Initialized( flag, ierr ) if (.not. flag) then call MPI_Init( ierr ) endif dbgflag = .false. call MPI_Comm_rank( MPI_COMM_WORLD, wrank, ierr ) end ! subroutine MTest_Finalize( errs ) use mpi integer errs integer rank, toterrs, ierr call MPI_Comm_rank( MPI_COMM_WORLD, rank, ierr ) call MPI_Allreduce( errs, toterrs, 1, MPI_INTEGER, MPI_SUM, & & MPI_COMM_WORLD, ierr ) if (rank .eq. 0) then if (toterrs .gt. 0) then print *, " Found ", toterrs, " errors" else print *, " No Errors" endif endif end ! ! A simple get intracomm for now logical function MTestGetIntracomm( comm, min_size, qsmaller ) use mpi integer ierr integer comm, min_size, size, rank logical qsmaller integer myindex save myindex data myindex /0/ if (.false.) then qsmaller = qsmaller endif comm = MPI_COMM_NULL if (myindex .eq. 0) then comm = MPI_COMM_WORLD else if (myindex .eq. 1) then call mpi_comm_dup( MPI_COMM_WORLD, comm, ierr ) else if (myindex .eq. 2) then call mpi_comm_size( MPI_COMM_WORLD, size, ierr ) call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) call mpi_comm_split( MPI_COMM_WORLD, 0, size - rank, comm, & & ierr ) else if (min_size .eq. 1 .and. myindex .eq. 3) then comm = MPI_COMM_SELF endif endif myindex = mod( myindex, 4 ) + 1 MTestGetIntracomm = comm .ne. MPI_COMM_NULL end ! subroutine MTestFreeComm( comm ) use mpi integer comm, ierr if (comm .ne. MPI_COMM_WORLD .and. & & comm .ne. MPI_COMM_SELF .and. & & comm .ne. MPI_COMM_NULL) then call mpi_comm_free( comm, ierr ) endif end ! subroutine MTestPrintError( errcode ) use mpi integer errcode integer errclass, slen, ierr character*(MPI_MAX_ERROR_STRING) string call MPI_Error_class( errcode, errclass, ierr ) call MPI_Error_string( errcode, string, slen, ierr ) print *, "Error class ", errclass, "(", string(1:slen), ")" end ! subroutine MTestPrintErrorMsg( msg, errcode ) use mpi character*(*) msg integer errcode integer errclass, slen, ierr character*(MPI_MAX_ERROR_STRING) string call MPI_Error_class( errcode, errclass, ierr ) call MPI_Error_string( errcode, string, slen, ierr ) print *, msg, ": Error class ", errclass, " & & (", string(1:slen), ")" end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/util/CMakeLists.txt000644 001750 001750 00000001255 12342443654 023276 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite AND SMPI_F90) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpif90") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") #F90 version of the mtest library add_library(mtest_f90 STATIC ../util/mtestf90.f90) endif() set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/../util/mtestf90.f90 PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/testlist000644 001750 001750 00000000132 12342443666 021353 0ustar00cici000000 000000 #attr coll #comm #ext #info init #io #misc pt2pt datatype #f90types # #spawn #timer #topo SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/init/000755 001750 001750 00000000000 12342443666 020524 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/init/testlist000644 001750 001750 00000000057 12342443666 022324 0ustar00cici000000 000000 # This file generated by f77tof90 baseenvf90 1 SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/init/baseenvf90.f90000644 001750 001750 00000005374 12342443662 023013 0ustar00cici000000 000000 ! This file created from test/mpi/f77/init/baseenvf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer ierr, provided, errs, rank, size integer iv, isubv, qprovided logical flag errs = 0 flag = .true. call mpi_finalized( flag, ierr ) if (flag) then errs = errs + 1 print *, 'Returned true for finalized before init' endif flag = .true. call mpi_initialized( flag, ierr ) if (flag) then errs = errs + 1 print *, 'Return true for initialized before init' endif provided = -1 call mpi_init_thread( MPI_THREAD_MULTIPLE, provided, ierr ) if (provided .ne. MPI_THREAD_MULTIPLE .and. & & provided .ne. MPI_THREAD_SERIALIZED .and. & & provided .ne. MPI_THREAD_FUNNELED .and. & & provided .ne. MPI_THREAD_SINGLE) then errs = errs + 1 print *, ' Unrecognized value for provided = ', provided endif iv = -1 isubv = -1 call mpi_get_version( iv, isubv, ierr ) if (iv .ne. MPI_VERSION .or. isubv .ne. MPI_SUBVERSION) then errs = errs + 1 print *, 'Version in mpif.h and get_version do not agree' print *, 'Version in mpif.h is ', MPI_VERSION, '.', & & MPI_SUBVERSION print *, 'Version in get_version is ', iv, '.', isubv endif if (iv .lt. 1 .or. iv .gt. 3) then errs = errs + 1 print *, 'Version of MPI is invalid (=', iv, ')' endif if (isubv.lt.0 .or. isubv.gt.2) then errs = errs + 1 print *, 'Subversion of MPI is invalid (=', isubv, ')' endif call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) call mpi_comm_size( MPI_COMM_WORLD, size, ierr ) flag = .false. call mpi_is_thread_main( flag, ierr ) if (.not.flag) then errs = errs + 1 print *, 'is_thread_main returned false for main thread' endif call mpi_query_thread( qprovided, ierr ) if (qprovided .ne. provided) then errs = errs + 1 print *,'query thread and init thread disagree on'// & & ' thread level' endif call mpi_finalize( ierr ) flag = .false. call mpi_finalized( flag, ierr ) if (.not. flag) then errs = errs + 1 print *, 'finalized returned false after finalize' endif if (rank .eq. 0) then if (errs .eq. 0) then print *, ' No Errors' else print *, ' Found ', errs, ' errors' endif endif end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/init/CMakeLists.txt000644 001750 001750 00000001636 12342443654 023267 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite AND SMPI_F90) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpif90") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(baseenvf90 baseenvf90.f90) target_link_libraries(baseenvf90 simgrid mtest_f90) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/baseenvf90.f90 PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/000755 001750 001750 00000000000 12342443666 021374 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/hindexed_blockf90.f90000644 001750 001750 00000013125 12342443662 025173 0ustar00cici000000 000000 ! This file created from test/mpi/f77/datatype/hindexed_blockf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer errs, ierr, i, intsize integer type1, type2, type3, type4, type5 integer max_asizev parameter (max_asizev = 10) integer (kind=MPI_ADDRESS_KIND) aint, aintv(max_asizev) integer blocklens(max_asizev), dtypes(max_asizev) integer recvbuf(6*max_asizev) integer sendbuf(max_asizev), status(MPI_STATUS_SIZE) integer rank, size errs = 0 call mtest_init( ierr ) call mpi_comm_size( MPI_COMM_WORLD, size, ierr ) call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) ! call mpi_type_size( MPI_INTEGER, intsize, ierr ) ! aintv(1) = 0 aintv(2) = 3 * intsize call mpi_type_create_resized( MPI_INTEGER, aintv(1), aintv(2), & & type1, ierr ) call mpi_type_commit( type1, ierr ) aintv(1) = -1 aintv(2) = -1 call mpi_type_get_extent( type1, aintv(1), aintv(2), ierr ) if (aintv(1) .ne. 0) then errs = errs + 1 print *, 'Did not get expected lb' endif if (aintv(2) .ne. 3*intsize) then errs = errs + 1 print *, 'Did not get expected extent' endif aintv(1) = -1 aintv(2) = -1 call mpi_type_get_true_extent( type1, aintv(1), aintv(2), ierr ) if (aintv(1) .ne. 0) then errs = errs + 1 print *, 'Did not get expected true lb' endif if (aintv(2) .ne. intsize) then errs = errs + 1 print *, 'Did not get expected true extent (', aintv(2), ') ', & & ' expected ', intsize endif ! do i=1,10 blocklens(i) = 1 aintv(i) = (i-1) * 3 * intsize enddo call mpi_type_create_hindexed( 10, blocklens, aintv, & & MPI_INTEGER, type2, ierr ) call mpi_type_commit( type2, ierr ) ! aint = 3 * intsize call mpi_type_create_hvector( 10, 1, aint, MPI_INTEGER, type3, & & ierr ) call mpi_type_commit( type3, ierr ) ! do i=1,10 blocklens(i) = 1 dtypes(i) = MPI_INTEGER aintv(i) = (i-1) * 3 * intsize enddo call mpi_type_create_struct( 10, blocklens, aintv, dtypes, & & type4, ierr ) call mpi_type_commit( type4, ierr ) call mpi_type_get_extent(MPI_INTEGER, aintv(1), aint, ierr) do i=1,10 aintv(i) = (i-1) * 3 * aint enddo call mpi_type_create_hindexed_block( 10, 1, aintv, & & MPI_INTEGER, type5, ierr ) call mpi_type_commit( type5, ierr ) ! ! Using each time, send and receive using these types do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & & recvbuf, max_asizev, type1, rank, 0, & & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type1:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo ! do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & & recvbuf, 1, type2, rank, 0, & & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type2:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo ! do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & & recvbuf, 1, type3, rank, 0, & & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type3:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo ! do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & & recvbuf, 1, type4, rank, 0, & & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type4:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo ! do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & & recvbuf, 1, type5, rank, 0, & & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type5:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo ! call mpi_type_free( type1, ierr ) call mpi_type_free( type2, ierr ) call mpi_type_free( type3, ierr ) call mpi_type_free( type4, ierr ) call mpi_type_free( type5, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/typesubf90.f90000644 001750 001750 00000004251 12342443662 023724 0ustar00cici000000 000000 ! This file created from test/mpi/f77/datatype/typesubf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer errs, ierr integer maxn, maxm parameter (maxn=10,maxm=15) integer fullsizes(2), subsizes(2), starts(2) integer fullarr(maxn,maxm),subarr(maxn-3,maxm-4) integer i,j, ssize integer newtype, size, rank, ans errs = 0 call mtest_init( ierr ) call mpi_comm_size( MPI_COMM_WORLD, size, ierr ) call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) ! ! Create a Fortran-style subarray fullsizes(1) = maxn fullsizes(2) = maxm subsizes(1) = maxn - 3 subsizes(2) = maxm - 4 ! starts are from zero, even in Fortran starts(1) = 1 starts(2) = 2 ! In Fortran 90 notation, the original array is ! integer a(maxn,maxm) ! and the subarray is ! a(1+1:(maxn-3) +(1+1)-1,2+1:(maxm-4)+(2+1)-1) ! i.e., a (start:(len + start - 1),...) call mpi_type_create_subarray( 2, fullsizes, subsizes, starts, & & MPI_ORDER_FORTRAN, MPI_INTEGER, newtype, ierr ) call mpi_type_commit( newtype, ierr ) ! ! Prefill the array do j=1, maxm do i=1, maxn fullarr(i,j) = (i-1) + (j-1) * maxn enddo enddo do j=1, subsizes(2) do i=1, subsizes(1) subarr(i,j) = -1 enddo enddo ssize = subsizes(1)*subsizes(2) call mpi_sendrecv( fullarr, 1, newtype, rank, 0, & & subarr, ssize, MPI_INTEGER, rank, 0, & & MPI_COMM_WORLD, MPI_STATUS_IGNORE, ierr ) ! ! Check the data do j=1, subsizes(2) do i=1, subsizes(1) ans = (i+starts(1)-1) + (j+starts(2)-1) * maxn if (subarr(i,j) .ne. ans) then errs = errs + 1 if (errs .le. 10) then print *, rank, 'subarr(',i,',',j,') = ', subarr(i,j) endif endif enddo enddo call mpi_type_free( newtype, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/sizeof.f90000644 001750 001750 00000010326 12342443662 023211 0ustar00cici000000 000000 ! -*- Mode: Fortran; -*- ! ! (C) 2007 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! This program tests that the MPI_SIZEOF routine is implemented for the ! predefined scalar Fortran types. It confirms that the size of these ! types matches the size of the corresponding MPI datatypes. ! program main use mpi integer ierr, errs integer rank, size, mpisize logical verbose real r1,r1v(2) double precision d1,d1v(3) complex c1,c1v(4) integer i1,i1v(5) character ch1,ch1v(6) logical l1,l1v(7) verbose = .false. errs = 0 call mtest_init ( ierr ) call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) ! Test of scalar types call mpi_sizeof( r1, size, ierr ) call mpi_type_size( MPI_REAL, mpisize, ierr ) if (size .ne. mpisize) then errs = errs + 1 print *, "Size of MPI_REAL = ", mpisize, & & " but MPI_SIZEOF gives ", size endif call mpi_sizeof( d1, size, ierr ) call mpi_type_size( MPI_DOUBLE_PRECISION, mpisize, ierr ) if (size .ne. mpisize) then errs = errs + 1 print *, "Size of MPI_DOUBLE_PRECISION = ", mpisize, & " but MPI_SIZEOF gives ", size endif call mpi_sizeof( i1, size, ierr ) call mpi_type_size( MPI_INTEGER, mpisize, ierr ) if (size .ne. mpisize) then errs = errs + 1 print *, "Size of MPI_INTEGER = ", mpisize, & & " but MPI_SIZEOF gives ", size endif call mpi_sizeof( c1, size, ierr ) call mpi_type_size( MPI_COMPLEX, mpisize, ierr ) if (size .ne. mpisize) then errs = errs + 1 print *, "Size of MPI_COMPLEX = ", mpisize, & & " but MPI_SIZEOF gives ", size endif call mpi_sizeof( ch1, size, ierr ) call mpi_type_size( MPI_CHARACTER, mpisize, ierr ) if (size .ne. mpisize) then errs = errs + 1 print *, "Size of MPI_CHARACTER = ", mpisize, & " but MPI_SIZEOF gives ", size endif call mpi_sizeof( l1, size, ierr ) call mpi_type_size( MPI_LOGICAL, mpisize, ierr ) if (size .ne. mpisize) then errs = errs + 1 print *, "Size of MPI_LOGICAL = ", mpisize, & & " but MPI_SIZEOF gives ", size endif ! ! Test of vector types (1-dimensional) call mpi_sizeof( r1v, size, ierr ) call mpi_type_size( MPI_REAL, mpisize, ierr ) if (size .ne. mpisize) then errs = errs + 1 print *, "Size of MPI_REAL = ", mpisize, & & " but MPI_SIZEOF gives ", size endif call mpi_sizeof( d1v, size, ierr ) call mpi_type_size( MPI_DOUBLE_PRECISION, mpisize, ierr ) if (size .ne. mpisize) then errs = errs + 1 print *, "Size of MPI_DOUBLE_PRECISION = ", mpisize, & " but MPI_SIZEOF gives ", size endif call mpi_sizeof( i1v, size, ierr ) call mpi_type_size( MPI_INTEGER, mpisize, ierr ) if (size .ne. mpisize) then errs = errs + 1 print *, "Size of MPI_INTEGER = ", mpisize, & & " but MPI_SIZEOF gives ", size endif call mpi_sizeof( c1v, size, ierr ) call mpi_type_size( MPI_COMPLEX, mpisize, ierr ) if (size .ne. mpisize) then errs = errs + 1 print *, "Size of MPI_COMPLEX = ", mpisize, & & " but MPI_SIZEOF gives ", size endif call mpi_sizeof( ch1v, size, ierr ) call mpi_type_size( MPI_CHARACTER, mpisize, ierr ) if (size .ne. mpisize) then errs = errs + 1 print *, "Size of MPI_CHARACTER = ", mpisize, & " but MPI_SIZEOF gives ", size endif call mpi_sizeof( l1v, size, ierr ) call mpi_type_size( MPI_LOGICAL, mpisize, ierr ) if (size .ne. mpisize) then errs = errs + 1 print *, "Size of MPI_LOGICAL = ", mpisize, & & " but MPI_SIZEOF gives ", size endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/createf90.f90000644 001750 001750 00000004404 12342443662 023474 0ustar00cici000000 000000 ! ! (C) 2004 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer ierr integer errs integer nints, nadds, ndtypes, combiner integer nparms(2), dummy(1) integer (kind=MPI_ADDRESS_KIND) adummy(1) integer ntype1, nsize, ntype2, ntype3, i ! ! Test the Type_create_f90_xxx routines ! errs = 0 call mtest_init( ierr ) ! integers with upto 9 are 4 bytes integers; r of 4 are 2 byte, ! and r of 2 is 1 byte call mpi_type_create_f90_integer( 9, ntype1, ierr ) ! ! Check with get contents and envelope... call mpi_type_get_envelope( ntype1, nints, nadds, ndtypes, & combiner, ierr ) if (nadds .ne. 0) then errs = errs + 1 print *, "There should be no addresses on created type (r=9)" endif if (ndtypes .ne. 0) then errs = errs + 1 print *, "There should be no datatypes on created type (r=9)" endif if (nints .ne. 1) then errs = errs + 1 print *, "There should be exactly 1 integer on create type (r=9)" endif if (combiner .ne. MPI_COMBINER_F90_INTEGER) then errs = errs + 1 print *, "The combiner should be INTEGER, not ", combiner endif if (nints .eq. 1) then call mpi_type_get_contents( ntype1, 1, 0, 0, & nparms, adummy, dummy, ierr ) if (nparms(1) .ne. 9) then errs = errs + 1 print *, "parameter was ", nparms(1), " should be 9" endif endif call mpi_type_create_f90_integer( 8, ntype2, ierr ) if (ntype1 .eq. ntype2) then errs = errs + 1 print *, "Types with r = 8 and r = 9 are the same, ", & "should be distinct" endif ! ! Check that we don't create new types each time. This test will fail only ! if the MPI implementation checks for un-freed types or runs out of space do i=1, 100000 call mpi_type_create_f90_integer( 8, ntype3, ierr ) enddo call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/testlist000644 001750 001750 00000000516 12342443666 023174 0ustar00cici000000 000000 # This file generated by f77tof90 #typenamef90 1 #typename3f90 1 mpiversion=3.0 #typesnamef90 1 #typecntsf90 1 #typem2f90 1 #typesubf90 1 #packef90 1 gaddressf90 1 #allctypesf90 1 #hindex1f90 1 #hindexed_blockf90 1 mpiversion=1.0 #structf 2 indtype 2 #createf90 1 #sizeof 1 kinds 2 mpiversion=1.0 #trf90 1 #get_elem_d 2 #get_elem_u 2 SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/packef90.f90000644 001750 001750 00000015354 12342443662 023322 0ustar00cici000000 000000 ! This file created from test/mpi/f77/datatype/packef.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer ierr, errs integer inbuf(10), ioutbuf(10), inbuf2(10), ioutbuf2(10) integer i, insize, rsize, csize, insize2 character*(16) cbuf, coutbuf double precision rbuf(10), routbuf(10) integer packbuf(1000), pbufsize, intsize integer max_asizev parameter (max_asizev = 3) integer (kind=MPI_ADDRESS_KIND) aint, aintv(max_asizev) errs = 0 call mtest_init( ierr ) call mpi_type_size( MPI_INTEGER, intsize, ierr ) pbufsize = 1000 * intsize call mpi_pack_external_size( 'external32', 10, MPI_INTEGER, & & aint, ierr ) if (aint .ne. 10 * 4) then errs = errs + 1 print *, 'Expected 40 for size of 10 external32 integers', & & ', got ', aint endif call mpi_pack_external_size( 'external32', 10, MPI_LOGICAL, & & aint, ierr ) if (aint .ne. 10 * 4) then errs = errs + 1 print *, 'Expected 40 for size of 10 external32 logicals', & & ', got ', aint endif call mpi_pack_external_size( 'external32', 10, MPI_CHARACTER, & & aint, ierr ) if (aint .ne. 10 * 1) then errs = errs + 1 print *, 'Expected 10 for size of 10 external32 characters', & & ', got ', aint endif call mpi_pack_external_size( 'external32', 3, MPI_INTEGER2, & & aint, ierr ) if (aint .ne. 3 * 2) then errs = errs + 1 print *, 'Expected 6 for size of 3 external32 INTEGER*2', & & ', got ', aint endif call mpi_pack_external_size( 'external32', 3, MPI_INTEGER4, & & aint, ierr ) if (aint .ne. 3 * 4) then errs = errs + 1 print *, 'Expected 12 for size of 3 external32 INTEGER*4', & & ', got ', aint endif call mpi_pack_external_size( 'external32', 3, MPI_REAL4, & & aint, ierr ) if (aint .ne. 3 * 4) then errs = errs + 1 print *, 'Expected 12 for size of 3 external32 REAL*4', & & ', got ', aint endif call mpi_pack_external_size( 'external32', 3, MPI_REAL8, & & aint, ierr ) if (aint .ne. 3 * 8) then errs = errs + 1 print *, 'Expected 24 for size of 3 external32 REAL*8', & & ', got ', aint endif if (MPI_INTEGER1 .ne. MPI_DATATYPE_NULL) then call mpi_pack_external_size( 'external32', 3, MPI_INTEGER1, & & aint, ierr ) if (aint .ne. 3 * 1) then errs = errs + 1 print *, 'Expected 3 for size of 3 external32 INTEGER*1', & & ', got ', aint endif endif if (MPI_INTEGER8 .ne. MPI_DATATYPE_NULL) then call mpi_pack_external_size( 'external32', 3, MPI_INTEGER8, & & aint, ierr ) if (aint .ne. 3 * 8) then errs = errs + 1 print *, 'Expected 24 for size of 3 external32 INTEGER*8', & & ', got ', aint endif endif ! ! Initialize values ! insize = 10 do i=1, insize inbuf(i) = i enddo rsize = 3 do i=1, rsize rbuf(i) = 1000.0 * i enddo cbuf = 'This is a string' csize = 16 insize2 = 7 do i=1, insize2 inbuf2(i) = 5000-i enddo ! aintv(1) = pbufsize aintv(2) = 0 aintv(3) = 0 ! One MPI implementation failed to increment the position; instead, ! it set the value with the amount of data packed in this call ! We use aintv(3) to detect and report this specific error call mpi_pack_external( 'external32', inbuf, insize, MPI_INTEGER, & & packbuf, aintv(1), aintv(2), ierr ) if (aintv(2) .le. aintv(3)) then print *, ' Position decreased after pack of integer!' endif aintv(3) = aintv(2) call mpi_pack_external( 'external32', rbuf, rsize, & & MPI_DOUBLE_PRECISION, packbuf, aintv(1), & & aintv(2), ierr ) if (aintv(2) .le. aintv(3)) then print *, ' Position decreased after pack of real!' endif aintv(3) = aintv(2) call mpi_pack_external( 'external32', cbuf, csize, & & MPI_CHARACTER, packbuf, aintv(1), & & aintv(2), ierr ) if (aintv(2) .le. aintv(3)) then print *, ' Position decreased after pack of character!' endif aintv(3) = aintv(2) call mpi_pack_external( 'external32', inbuf2, insize2, & & MPI_INTEGER, & & packbuf, aintv(1), aintv(2), ierr ) if (aintv(2) .le. aintv(3)) then print *, ' Position decreased after pack of integer (2nd)!' endif aintv(3) = aintv(2) ! ! We could try sending this with MPI_BYTE... aintv(2) = 0 call mpi_unpack_external( 'external32', packbuf, aintv(1), & & aintv(2), ioutbuf, insize, MPI_INTEGER, ierr ) call mpi_unpack_external( 'external32', packbuf, aintv(1), & & aintv(2), routbuf, rsize, MPI_DOUBLE_PRECISION, ierr ) call mpi_unpack_external( 'external32', packbuf, aintv(1), & & aintv(2), coutbuf, csize, MPI_CHARACTER, ierr ) call mpi_unpack_external( 'external32', packbuf, aintv(1), & & aintv(2), ioutbuf2, insize2, MPI_INTEGER, ierr ) ! ! Now, test the values ! do i=1, insize if (ioutbuf(i) .ne. i) then errs = errs + 1 print *, 'ioutbuf(',i,') = ', ioutbuf(i), ' expected ', i endif enddo do i=1, rsize if (routbuf(i) .ne. 1000.0 * i) then errs = errs + 1 print *, 'routbuf(',i,') = ', routbuf(i), ' expected ', & & 1000.0 * i endif enddo if (coutbuf(1:csize) .ne. 'This is a string') then errs = errs + 1 print *, 'coutbuf = ', coutbuf(1:csize), ' expected ', & & 'This is a string' endif do i=1, insize2 if (ioutbuf2(i) .ne. 5000-i) then errs = errs + 1 print *, 'ioutbuf2(',i,') = ', ioutbuf2(i), ' expected ', & & 5000-i endif enddo ! call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/typem2f90.f90000644 001750 001750 00000013065 12342443662 023454 0ustar00cici000000 000000 ! This file created from test/mpi/f77/datatype/typem2f.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer errs, ierr, i, intsize integer type1, type2, type3, type4, type5 integer max_asizev parameter (max_asizev = 10) integer (kind=MPI_ADDRESS_KIND) aint, aintv(max_asizev) integer blocklens(max_asizev), dtypes(max_asizev) integer displs(max_asizev) integer recvbuf(6*max_asizev) integer sendbuf(max_asizev), status(MPI_STATUS_SIZE) integer rank, size errs = 0 call mtest_init( ierr ) call mpi_comm_size( MPI_COMM_WORLD, size, ierr ) call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) ! call mpi_type_size( MPI_INTEGER, intsize, ierr ) ! aintv(1) = 0 aintv(2) = 3 * intsize call mpi_type_create_resized( MPI_INTEGER, aintv(1), aintv(2), & & type1, ierr ) call mpi_type_commit( type1, ierr ) aintv(1) = -1 aintv(2) = -1 call mpi_type_get_extent( type1, aintv(1), aintv(2), ierr ) if (aintv(1) .ne. 0) then errs = errs + 1 print *, 'Did not get expected lb' endif if (aintv(2) .ne. 3*intsize) then errs = errs + 1 print *, 'Did not get expected extent' endif aintv(1) = -1 aintv(2) = -1 call mpi_type_get_true_extent( type1, aintv(1), aintv(2), ierr ) if (aintv(1) .ne. 0) then errs = errs + 1 print *, 'Did not get expected true lb' endif if (aintv(2) .ne. intsize) then errs = errs + 1 print *, 'Did not get expected true extent (', aintv(2), ') ', & & ' expected ', intsize endif ! do i=1,10 blocklens(i) = 1 aintv(i) = (i-1) * 3 * intsize enddo call mpi_type_create_hindexed( 10, blocklens, aintv, & & MPI_INTEGER, type2, ierr ) call mpi_type_commit( type2, ierr ) ! aint = 3 * intsize call mpi_type_create_hvector( 10, 1, aint, MPI_INTEGER, type3, & & ierr ) call mpi_type_commit( type3, ierr ) ! do i=1,10 blocklens(i) = 1 dtypes(i) = MPI_INTEGER aintv(i) = (i-1) * 3 * intsize enddo call mpi_type_create_struct( 10, blocklens, aintv, dtypes, & & type4, ierr ) call mpi_type_commit( type4, ierr ) do i=1,10 displs(i) = (i-1) * 3 enddo call mpi_type_create_indexed_block( 10, 1, displs, & & MPI_INTEGER, type5, ierr ) call mpi_type_commit( type5, ierr ) ! ! Using each time, send and receive using these types do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & & recvbuf, max_asizev, type1, rank, 0, & & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type1:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo ! do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & & recvbuf, 1, type2, rank, 0, & & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type2:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo ! do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & & recvbuf, 1, type3, rank, 0, & & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type3:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo ! do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & & recvbuf, 1, type4, rank, 0, & & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type4:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo ! do i=1, max_asizev*3 recvbuf(i) = -1 enddo do i=1, max_asizev sendbuf(i) = i enddo call mpi_sendrecv( sendbuf, max_asizev, MPI_INTEGER, rank, 0, & & recvbuf, 1, type5, rank, 0, & & MPI_COMM_WORLD, status, ierr ) do i=1, max_asizev if (recvbuf(1+(i-1)*3) .ne. i ) then errs = errs + 1 print *, 'type5:', i, 'th element = ', recvbuf(1+(i-1)*3) endif enddo ! call mpi_type_free( type1, ierr ) call mpi_type_free( type2, ierr ) call mpi_type_free( type3, ierr ) call mpi_type_free( type4, ierr ) call mpi_type_free( type5, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/indtype.f90000644 001750 001750 00000005651 12342443662 023373 0ustar00cici000000 000000 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! This test contributed by Kim McMahon, Cray ! program main implicit none use mpi integer ierr, i, j, type, count,errs parameter (count = 4) integer rank, size, xfersize integer status(MPI_STATUS_SIZE) integer blocklens(count), displs(count) double precision,dimension(:,:),allocatable :: sndbuf, rcvbuf logical verbose verbose = .false. call mtest_init ( ierr ) call mpi_comm_size( MPI_COMM_WORLD, size, ierr ) call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) if (size .lt. 2) then print *, "Must have at least 2 processes" call MPI_Abort( MPI_COMM_WORLD, 1, ierr ) stop endif errs = 0 allocate(sndbuf(7,100)) allocate(rcvbuf(7,100)) do j=1,100 do i=1,7 sndbuf(i,j) = (i+j) * 1.0 enddo enddo do i=1,count blocklens(i) = 7 enddo ! bug occurs when first two displacements are 0 displs(1) = 0 displs(2) = 0 displs(3) = 10 displs(4) = 10 call mpi_type_indexed( count, blocklens, displs*blocklens(1), & & MPI_DOUBLE_PRECISION, type, ierr ) call mpi_type_commit( type, ierr ) ! send using this new type if (rank .eq. 0) then call mpi_send( sndbuf(1,1), 1, type, 1, 0, MPI_COMM_WORLD,ierr ) else if (rank .eq. 1) then xfersize=count * blocklens(1) call mpi_recv( rcvbuf(1,1), xfersize, MPI_DOUBLE_PRECISION, 0, 0, & & MPI_COMM_WORLD,status, ierr ) ! Values that should be sent if (verbose) then ! displacement = 0 j=1 do i=1, 7 print*,'sndbuf(',i,j,') = ',sndbuf(i,j) enddo ! displacement = 10 j=11 do i=1,7 print*,'sndbuf(',i,j,') = ',sndbuf(i,j) enddo print*,' ' ! Values received do j=1,count do i=1,7 print*,'rcvbuf(',i,j,') = ',rcvbuf(i,j) enddo enddo endif ! Error checking do j=1,2 do i=1,7 if (rcvbuf(i,j) .ne. sndbuf(i,1)) then print*,'ERROR in rcvbuf(',i,j,')' print*,'Received ', rcvbuf(i,j),' expected ',sndbuf(i,11) errs = errs+1 endif enddo enddo do j=3,4 do i=1,7 if (rcvbuf(i,j) .ne. sndbuf(i,11)) then print*,'ERROR in rcvbuf(',i,j,')' print*,'Received ', rcvbuf(i,j),' expected ',sndbuf(i,11) errs = errs+1 endif enddo enddo endif ! call mpi_type_free( type, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/kinds.f90000644 001750 001750 00000006353 12342443662 023027 0ustar00cici000000 000000 ! -*- Mode: Fortran; -*- ! ! (C) 2011 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! This program tests that all of the integer kinds defined in MPI 2.2 are ! available. ! program main use mpi integer (kind=MPI_ADDRESS_KIND) aint, taint integer (kind=MPI_OFFSET_KIND) oint, toint integer (kind=MPI_INTEGER_KIND) iint, tiint integer s(MPI_STATUS_SIZE) integer i, wsize, wrank, ierr, errs ! errs = 0 ! call MTEST_INIT(ierr) call MPI_COMM_SIZE(MPI_COMM_WORLD,wsize,ierr) call MPI_COMM_RANK(MPI_COMM_WORLD,wrank,ierr) if (wsize .lt. 2) then print *, "This test requires at least 2 processes" call MPI_ABORT( MPI_COMM_WORLD, 1, ierr ) endif ! ! Some compilers (e.g., gfortran) will issue an error if, at compile time, ! an assignment would cause overflow, even if appropriated guarded. To ! avoid this problem, we must compute the value in the integer (the ! code here is simple; there are faster fixes for this but this is easy if (wrank .eq. 0) then if (range(aint) .ge. 10) then aint = 1 do i=1, range(aint)-1 aint = aint * 10 enddo aint = aint - 1 else aint = 12345678 endif if (range(oint) .ge. 10) then oint = 1 do i=1, range(oint)-1 oint = oint * 10 enddo oint = oint - 1 else oint = 12345678 endif if (range(iint) .ge. 10) then iint = 1 do i=1, range(iint)-1 iint = iint * 10 enddo iint = iint - 1 else iint = 12345678 endif call MPI_SEND( aint, 1, MPI_AINT, 1, 0, MPI_COMM_WORLD, ierr ) call MPI_SEND( oint, 1, MPI_OFFSET, 1, 1, MPI_COMM_WORLD, ierr ) call MPI_SEND( iint, 1, MPI_INTEGER, 1, 2, MPI_COMM_WORLD, ierr ) ! else if (wrank .eq. 1) then if (range(taint) .ge. 10) then taint = 1 do i=1, range(taint)-1 taint = taint * 10 enddo taint = taint - 1 else taint = 12345678 endif if (range(toint) .ge. 10) then toint = 1 do i=1, range(toint)-1 toint = toint * 10 enddo toint = toint - 1 else toint = 12345678 endif if (range(tiint) .ge. 10) then tiint = 1 do i=1, range(tiint)-1 tiint = tiint * 10 enddo tiint = tiint - 1 else tiint = 12345678 endif call MPI_RECV( aint, 1, MPI_AINT, 0, 0, MPI_COMM_WORLD, s, ierr ) if (taint .ne. aint) then print *, "Address-sized int not correctly transfered" print *, "Value should be ", taint, " but is ", aint errs = errs + 1 endif call MPI_RECV( oint, 1, MPI_OFFSET, 0, 1, MPI_COMM_WORLD, s, ierr ) if (toint .ne. oint) then print *, "Offset-sized int not correctly transfered" print *, "Value should be ", toint, " but is ", oint errs = errs + 1 endif call MPI_RECV( iint, 1, MPI_INTEGER, 0, 2, MPI_COMM_WORLD, s, ierr ) if (tiint .ne. iint) then print *, "Integer (by kind) not correctly transfered" print *, "Value should be ", tiint, " but is ", iint errs = errs + 1 endif ! endif ! call MTEST_FINALIZE(errs) call MPI_FINALIZE(ierr) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/typenamef90.f90000644 001750 001750 00000016452 12342443662 024061 0ustar00cici000000 000000 ! This file created from test/mpi/f77/datatype/typenamef.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi character*(MPI_MAX_OBJECT_NAME) name integer namelen integer ierr, errs errs = 0 call mtest_init( ierr ) ! ! Check each Fortran datatype, including the size-specific ones ! See the C version (typename.c) for the relevant MPI sections call MPI_Type_get_name( MPI_COMPLEX, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_COMPLEX") then errs = errs + 1 print *, "Expected MPI_COMPLEX but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_DOUBLE_COMPLEX, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_DOUBLE_COMPLEX") then errs = errs + 1 print *, "Expected MPI_DOUBLE_COMPLEX but got "// & & name(1:namelen) endif call MPI_Type_get_name( MPI_LOGICAL, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_LOGICAL") then errs = errs + 1 print *, "Expected MPI_LOGICAL but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_REAL, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_REAL") then errs = errs + 1 print *, "Expected MPI_REAL but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_DOUBLE_PRECISION, name, namelen, ierr) if (name(1:namelen) .ne. "MPI_DOUBLE_PRECISION") then errs = errs + 1 print *, "Expected MPI_DOUBLE_PRECISION but got "// & & name(1:namelen) endif call MPI_Type_get_name( MPI_INTEGER, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_INTEGER") then errs = errs + 1 print *, "Expected MPI_INTEGER but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_2INTEGER, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_2INTEGER") then errs = errs + 1 print *, "Expected MPI_2INTEGER but got "//name(1:namelen) endif ! 2COMPLEX was present only in MPI 1.0 ! call MPI_Type_get_name( MPI_2COMPLEX, name, namelen, ierr ) ! if (name(1:namelen) .ne. "MPI_2COMPLEX") then ! errs = errs + 1 ! print *, "Expected MPI_2COMPLEX but got "//name(1:namelen) ! endif ! call MPI_Type_get_name(MPI_2DOUBLE_PRECISION, name, namelen, ierr) if (name(1:namelen) .ne. "MPI_2DOUBLE_PRECISION") then errs = errs + 1 print *, "Expected MPI_2DOUBLE_PRECISION but got "// & & name(1:namelen) endif call MPI_Type_get_name( MPI_2REAL, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_2REAL") then errs = errs + 1 print *, "Expected MPI_2REAL but got "//name(1:namelen) endif ! 2DOUBLE_COMPLEX isn't in MPI 2.1 ! call MPI_Type_get_name( MPI_2DOUBLE_COMPLEX, name, namelen, ierr ) ! if (name(1:namelen) .ne. "MPI_2DOUBLE_COMPLEX") then ! errs = errs + 1 ! print *, "Expected MPI_2DOUBLE_COMPLEX but got "// ! & name(1:namelen) ! endif call MPI_Type_get_name( MPI_CHARACTER, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_CHARACTER") then errs = errs + 1 print *, "Expected MPI_CHARACTER but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_BYTE, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_BYTE") then errs = errs + 1 print *, "Expected MPI_BYTE but got "//name(1:namelen) endif if (MPI_REAL4 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_REAL4, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_REAL4") then errs = errs + 1 print *, "Expected MPI_REAL4 but got "//name(1:namelen) endif endif if (MPI_REAL8 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_REAL8, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_REAL8") then errs = errs + 1 print *, "Expected MPI_REAL8 but got "//name(1:namelen) endif endif if (MPI_REAL16 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_REAL16, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_REAL16") then errs = errs + 1 print *, "Expected MPI_REAL16 but got "//name(1:namelen) endif endif if (MPI_COMPLEX8 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_COMPLEX8, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_COMPLEX8") then errs = errs + 1 print *, "Expected MPI_COMPLEX8 but got "// & & name(1:namelen) endif endif if (MPI_COMPLEX16 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_COMPLEX16, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_COMPLEX16") then errs = errs + 1 print *, "Expected MPI_COMPLEX16 but got "// & & name(1:namelen) endif endif if (MPI_COMPLEX32 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_COMPLEX32, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_COMPLEX32") then errs = errs + 1 print *, "Expected MPI_COMPLEX32 but got "// & & name(1:namelen) endif endif if (MPI_INTEGER1 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_INTEGER1, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_INTEGER1") then errs = errs + 1 print *, "Expected MPI_INTEGER1 but got "// & & name(1:namelen) endif endif if (MPI_INTEGER2 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_INTEGER2, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_INTEGER2") then errs = errs + 1 print *, "Expected MPI_INTEGER2 but got "// & & name(1:namelen) endif endif if (MPI_INTEGER4 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_INTEGER4, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_INTEGER4") then errs = errs + 1 print *, "Expected MPI_INTEGER4 but got "// & & name(1:namelen) endif endif if (MPI_INTEGER8 .ne. MPI_DATATYPE_NULL) then call MPI_Type_get_name( MPI_INTEGER8, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_INTEGER8") then errs = errs + 1 print *, "Expected MPI_INTEGER8 but got "// & & name(1:namelen) endif endif ! MPI_INTEGER16 is in MPI 2.1, but it is missing from most tables ! Some MPI implementations may not provide it ! if (MPI_INTEGER16 .ne. MPI_DATATYPE_NULL) then ! call MPI_Type_get_name( MPI_INTEGER16, name, namelen, ierr ) ! if (name(1:namelen) .ne. "MPI_INTEGER16") then ! errs = errs + 1 ! print *, "Expected MPI_INTEGER16 but got "// ! & name(1:namelen) ! endif ! endif call mtest_finalize( errs ) call MPI_Finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/hindex1f90.f90000644 001750 001750 00000003232 12342443662 023567 0ustar00cici000000 000000 ! This file created from test/mpi/f77/datatype/hindex1f.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! ! (C) 2011 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer errs, ierr, intsize integer i, displs(10), counts(10), dtype integer bufsize parameter (bufsize=100) integer inbuf(bufsize), outbuf(bufsize), packbuf(bufsize) integer position, len, psize ! ! Test for hindexed; ! errs = 0 call mtest_init( ierr ) call mpi_type_size( MPI_INTEGER, intsize, ierr ) do i=1, 10 displs(i) = (10-i)*intsize counts(i) = 1 enddo call mpi_type_hindexed( 10, counts, displs, MPI_INTEGER, dtype, & & ierr ) call mpi_type_commit( dtype, ierr ) ! call mpi_pack_size( 1, dtype, MPI_COMM_WORLD, psize, ierr ) if (psize .gt. bufsize*intsize) then errs = errs + 1 else do i=1,10 inbuf(i) = i outbuf(i) = -i enddo position = 0 call mpi_pack( inbuf, 1, dtype, packbuf, psize, position, & & MPI_COMM_WORLD, ierr ) ! len = position position = 0 call mpi_unpack( packbuf, len, position, outbuf, 10, & & MPI_INTEGER, MPI_COMM_WORLD, ierr ) ! do i=1, 10 if (outbuf(i) .ne. 11-i) then errs = errs + 1 print *, 'outbuf(',i,')=',outbuf(i),', expected ', 10-i endif enddo endif ! call mpi_type_free( dtype, ierr ) ! call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/structf.f90000644 001750 001750 00000006322 12342443662 023405 0ustar00cici000000 000000 ! ! (C) 2004 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! Thanks to ! William R. Magro ! for this test ! ! It has been modifiedly slightly to work with the automated MPI ! tests. ! WDG. ! ! It was further modified to use MPI_Get_address instead of MPI_Address ! for MPICH, and to fit in the MPICH test harness - WDG ! program bustit implicit none use mpi integer comm integer newtype integer me integer position integer type(5) integer length(5) integer (kind=MPI_ADDRESS_KIND) disp(5) integer bufsize integer errs, toterrs parameter (bufsize=100) character buf(bufsize) character name*(10) integer status(MPI_STATUS_SIZE) integer i, size double precision x integer src, dest integer ierr errs = 0 ! Enroll in MPI call mpi_init(ierr) ! get my rank call mpi_comm_rank(MPI_COMM_WORLD, me, ierr) call mpi_comm_size(MPI_COMM_WORLD, size, ierr ) if (size .lt. 2) then print *, "Must have at least 2 processes" call MPI_Abort( MPI_COMM_WORLD, 1, ierr ) stop endif comm = MPI_COMM_WORLD src = 0 dest = 1 if(me.eq.src) then i=5 x=5.1234d0 name="Hello" type(1)=MPI_CHARACTER length(1)=5 call mpi_get_address(name,disp(1),ierr) type(2)=MPI_DOUBLE_PRECISION length(2)=1 call mpi_get_address(x,disp(2),ierr) call mpi_type_create_struct(2,length,disp,type,newtype,ierr) call mpi_type_commit(newtype,ierr) call mpi_barrier( MPI_COMM_WORLD, ierr ) call mpi_send(MPI_BOTTOM,1,newtype,dest,1,comm,ierr) call mpi_type_free(newtype,ierr) ! write(*,*) "Sent ",name(1:5),x else ! Everyone calls barrier incase size > 2 call mpi_barrier( MPI_COMM_WORLD, ierr ) if (me.eq.dest) then position=0 name = " " x = 0.0d0 call mpi_recv(buf,bufsize,MPI_PACKED, src, & & 1, comm, status, ierr) call mpi_unpack(buf,bufsize,position, & & name,5,MPI_CHARACTER, comm,ierr) call mpi_unpack(buf,bufsize,position, & & x,1,MPI_DOUBLE_PRECISION, comm,ierr) ! Check the return values (/= is not-equal in F90) if (name /= "Hello") then errs = errs + 1 print *, "Received ", name, " but expected Hello" endif if (abs(x-5.1234) .gt. 1.0e-6) then errs = errs + 1 print *, "Received ", x, " but expected 5.1234" endif endif endif ! ! Sum up errs and report the result call mpi_reduce( errs, toterrs, 1, MPI_INTEGER, MPI_SUM, 0, & & MPI_COMM_WORLD, ierr ) if (me .eq. 0) then if (toterrs .eq. 0) then print *, " No Errors" else print *, " Found ", toterrs, " errors" endif endif call mpi_finalize(ierr) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/typename3f90.f90000644 001750 001750 00000002314 12342443662 024134 0ustar00cici000000 000000 ! This file created from test/mpi/f77/datatype/typename3f.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! ! (C) 2012 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi character*(MPI_MAX_OBJECT_NAME) name integer namelen integer ierr, errs errs = 0 call mtest_init( ierr ) ! ! Check each Fortran datatype, including the size-specific ones ! See the C version (typename.c) for the relevant MPI sections call MPI_Type_get_name( MPI_AINT, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_AINT") then errs = errs + 1 print *, "Expected MPI_AINT but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_OFFSET, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_OFFSET") then errs = errs + 1 print *, "Expected MPI_OFFSET but got "//name(1:namelen) endif call MPI_Type_get_name( MPI_COUNT, name, namelen, ierr ) if (name(1:namelen) .ne. "MPI_COUNT") then errs = errs + 1 print *, "Expected MPI_COUNT but got "//name(1:namelen) endif call mtest_finalize( errs ) call MPI_Finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/trf90.f90000644 001750 001750 00000001105 12342443662 022651 0ustar00cici000000 000000 ! -*- Mode: Fortran; -*- ! ! (C) 2011 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! Based on a sample program that triggered a segfault in MPICH program testf90_mpi implicit none use mpi integer errs integer :: rk_mpi, ierr, ctype errs = 0 call mtest_init(ierr) call MPI_Type_create_f90_real(15, MPI_UNDEFINED, rk_mpi, ierr) call MPI_Type_contiguous(19, rk_mpi, ctype, ierr) call MPI_Type_commit(ctype, ierr) call MPI_Type_free(ctype, ierr) call mtest_finalize(errs) call MPI_Finalize(ierr) end program testf90_mpi SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/typesnamef90.f90000644 001750 001750 00000003477 12342443662 024247 0ustar00cici000000 000000 ! This file created from test/mpi/f77/datatype/typesnamef.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi character*(MPI_MAX_OBJECT_NAME) cname integer rlen, ln integer ntype1, ntype2, errs, ierr errs = 0 call MTest_Init( ierr ) call mpi_type_vector( 10, 1, 100, MPI_INTEGER, ntype1, ierr ) rlen = -1 cname = 'XXXXXX' call mpi_type_get_name( ntype1, cname, rlen, ierr ) if (rlen .ne. 0) then errs = errs + 1 print *, ' Expected length 0, got ', rlen endif rlen = 0 do ln=MPI_MAX_OBJECT_NAME,1,-1 if (cname(ln:ln) .ne. ' ') then rlen = ln goto 100 endif enddo 100 continue if (rlen .ne. 0) then errs = errs + 1 print *, 'Datatype name is not all blank' endif ! ! now add a name, then dup call mpi_type_set_name( ntype1, 'a vector type', ierr ) call mpi_type_dup( ntype1, ntype2, ierr ) rlen = -1 cname = 'XXXXXX' call mpi_type_get_name( ntype2, cname, rlen, ierr ) if (rlen .ne. 0) then errs = errs + 1 print *, ' (type2) Expected length 0, got ', rlen endif rlen = 0 do ln=MPI_MAX_OBJECT_NAME,1,-1 if (cname(ln:ln) .ne. ' ') then rlen = ln goto 110 endif enddo 110 continue if (rlen .ne. 0) then errs = errs + 1 print *, ' (type2) Datatype name is not all blank' endif call mpi_type_free( ntype1, ierr ) call mpi_type_free( ntype2, ierr ) call MTest_Finalize( errs ) call MPI_Finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/get_elem_u.f90000644 001750 001750 00000003457 12342443662 024026 0ustar00cici000000 000000 ! -*- Mode: Fortran; -*- ! ! (C) 2013 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! Based on a test written by Jim Hoekstra on behalf of Cray, Inc. ! see ticket #884 https://trac.mpich.org/projects/mpich/ticket/884 PROGRAM get_elem_u USE mpi IMPLICIT NONE INTEGER RANK, SIZE, IERR, COMM, errs INTEGER MAX, I, K, dest INTEGER STATUS(MPI_STATUS_SIZE) INTEGER, PARAMETER :: nb=2 INTEGER :: blklen(nb)=(/1,1/) INTEGER :: types(nb)=(/MPI_DOUBLE_PRECISION,MPI_CHAR/) INTEGER(kind=MPI_ADDRESS_KIND) :: disp(nb)=(/0,8/) INTEGER, PARAMETER :: amax=200 INTEGER :: type1, type2, extent REAL :: a(amax) errs = 0 CALL MPI_Init( ierr ) COMM = MPI_COMM_WORLD CALL MPI_Comm_rank(COMM,RANK,IERR) CALL MPI_Comm_size(COMM,SIZE,IERR) dest=size-1 CALL MPI_Type_create_struct(nb, blklen, disp, types, type1, ierr) CALL MPI_Type_commit(type1, ierr) CALL MPI_Type_extent(type1, extent, ierr) CALL MPI_Type_contiguous(4, Type1, Type2, ierr) CALL MPI_Type_commit(Type2, ierr) CALL MPI_Type_extent(Type2, extent, ierr) DO k=1,17 IF(rank .EQ. 0) THEN ! send k copies of datatype Type1 CALL MPI_Send(a, k, Type1, dest, 0, comm, ierr) ELSE IF (rank == dest) THEN CALL MPI_Recv(a, 200, Type2, 0, 0, comm, status, ierr) CALL MPI_Get_elements(status, Type2, i, ierr) IF (i .NE. 2*k) THEN errs = errs+1 PRINT *, "k=",k," MPI_Get_elements returns", i, ", but it should be", 2*k END IF ELSE ! thix rank does not particupate END IF enddo CALL MPI_Type_free(type1, ierr) CALL MPI_Type_free(type2, ierr) CALL MPI_Finalize( ierr ) IF(rank .EQ. 0 .AND. errs .EQ. 0) THEN PRINT *, " No Errors" END IF END PROGRAM get_elem_u SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/allctypesf90.f90000644 001750 001750 00000012771 12342443662 024237 0ustar00cici000000 000000 ! This file created from test/mpi/f77/datatype/allctypesf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2004 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer ierr ! call mtest_init(ierr) call mpi_comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN, & & ierr ) ! ! Check that all Ctypes are available in Fortran (MPI 2.1, p 483, line 46) ! call checkdtype( MPI_CHAR, "MPI_CHAR", ierr ) call checkdtype( MPI_SIGNED_CHAR, "MPI_SIGNED_CHAR", ierr ) call checkdtype( MPI_UNSIGNED_CHAR, "MPI_UNSIGNED_CHAR", ierr ) call checkdtype( MPI_BYTE, "MPI_BYTE", ierr ) call checkdtype( MPI_WCHAR, "MPI_WCHAR", ierr ) call checkdtype( MPI_SHORT, "MPI_SHORT", ierr ) call checkdtype( MPI_UNSIGNED_SHORT, "MPI_UNSIGNED_SHORT", ierr ) call checkdtype( MPI_INT, "MPI_INT", ierr ) call checkdtype( MPI_UNSIGNED, "MPI_UNSIGNED", ierr ) call checkdtype( MPI_LONG, "MPI_LONG", ierr ) call checkdtype( MPI_UNSIGNED_LONG, "MPI_UNSIGNED_LONG", ierr ) call checkdtype( MPI_FLOAT, "MPI_FLOAT", ierr ) call checkdtype( MPI_DOUBLE, "MPI_DOUBLE", ierr ) if (MPI_LONG_DOUBLE .ne. MPI_DATATYPE_NULL) then call checkdtype( MPI_LONG_DOUBLE, "MPI_LONG_DOUBLE", ierr ) endif if (MPI_LONG_LONG_INT .ne. MPI_DATATYPE_NULL) then call checkdtype2( MPI_LONG_LONG_INT, "MPI_LONG_LONG_INT", & & "MPI_LONG_LONG", ierr ) endif if (MPI_UNSIGNED_LONG_LONG .ne. MPI_DATATYPE_NULL) then call checkdtype( MPI_UNSIGNED_LONG_LONG, & & "MPI_UNSIGNED_LONG_LONG", ierr ) endif if (MPI_LONG_LONG .ne. MPI_DATATYPE_NULL) then call checkdtype2( MPI_LONG_LONG, "MPI_LONG_LONG", & & "MPI_LONG_LONG_INT", ierr ) endif call checkdtype( MPI_PACKED, "MPI_PACKED", ierr ) call checkdtype( MPI_LB, "MPI_LB", ierr ) call checkdtype( MPI_UB, "MPI_UB", ierr ) call checkdtype( MPI_FLOAT_INT, "MPI_FLOAT_INT", ierr ) call checkdtype( MPI_DOUBLE_INT, "MPI_DOUBLE_INT", ierr ) call checkdtype( MPI_LONG_INT, "MPI_LONG_INT", ierr ) call checkdtype( MPI_SHORT_INT, "MPI_SHORT_INT", ierr ) call checkdtype( MPI_2INT, "MPI_2INT", ierr ) if (MPI_LONG_DOUBLE_INT .ne. MPI_DATATYPE_NULL) then call checkdtype( MPI_LONG_DOUBLE_INT, "MPI_LONG_DOUBLE_INT", & & ierr) endif ! ! Check that all Ctypes are available in Fortran (MPI 2.2) ! Note that because of implicit declarations in Fortran, this ! code should compile even with pre MPI 2.2 implementations. ! if (MPI_VERSION .gt. 2 .or. (MPI_VERSION .eq. 2 .and. & & MPI_SUBVERSION .ge. 2)) then call checkdtype( MPI_INT8_T, "MPI_INT8_T", ierr ) call checkdtype( MPI_INT16_T, "MPI_INT16_T", ierr ) call checkdtype( MPI_INT32_T, "MPI_INT32_T", ierr ) call checkdtype( MPI_INT64_T, "MPI_INT64_T", ierr ) call checkdtype( MPI_UINT8_T, "MPI_UINT8_T", ierr ) call checkdtype( MPI_UINT16_T, "MPI_UINT16_T", ierr ) call checkdtype( MPI_UINT32_T, "MPI_UINT32_T", ierr ) call checkdtype( MPI_UINT64_T, "MPI_UINT64_T", ierr ) ! other C99 types call checkdtype( MPI_C_BOOL, "MPI_C_BOOL", ierr ) call checkdtype( MPI_C_FLOAT_COMPLEX, "MPI_C_FLOAT_COMPLEX", & & ierr) call checkdtype2( MPI_C_COMPLEX, "MPI_C_COMPLEX", & & "MPI_C_FLOAT_COMPLEX", ierr ) call checkdtype( MPI_C_DOUBLE_COMPLEX, "MPI_C_DOUBLE_COMPLEX", & & ierr ) if (MPI_C_LONG_DOUBLE_COMPLEX .ne. MPI_DATATYPE_NULL) then call checkdtype( MPI_C_LONG_DOUBLE_COMPLEX, & & "MPI_C_LONG_DOUBLE_COMPLEX", ierr ) endif ! address/offset types call checkdtype( MPI_AINT, "MPI_AINT", ierr ) call checkdtype( MPI_OFFSET, "MPI_OFFSET", ierr ) endif ! call mtest_finalize( ierr ) call MPI_Finalize( ierr ) end ! ! Check name of datatype subroutine CheckDtype( intype, name, ierr ) use mpi integer intype, ierr character *(*) name integer ir, rlen character *(MPI_MAX_OBJECT_NAME) outname ! outname = "" call MPI_TYPE_GET_NAME( intype, outname, rlen, ir ) if (ir .ne. MPI_SUCCESS) then print *, " Datatype ", name, " not available in Fortran" ierr = ierr + 1 else if (outname .ne. name) then print *, " For datatype ", name, " found name ", & & outname(1:rlen) ierr = ierr + 1 endif endif return end ! ! Check name of datatype (allows alias) subroutine CheckDtype2( intype, name, name2, ierr ) use mpi integer intype, ierr character *(*) name, name2 integer ir, rlen character *(MPI_MAX_OBJECT_NAME) outname ! outname = "" call MPI_TYPE_GET_NAME( intype, outname, rlen, ir ) if (ir .ne. MPI_SUCCESS) then print *, " Datatype ", name, " not available in Fortran" ierr = ierr + 1 else if (outname .ne. name .and. outname .ne. name2) then print *, " For datatype ", name, " found name ", & & outname(1:rlen) ierr = ierr + 1 endif endif return end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/typecntsf90.f90000644 001750 001750 00000006555 12342443662 024113 0ustar00cici000000 000000 ! This file created from test/mpi/f77/datatype/typecntsf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer errs, ierr integer ntype1, ntype2 ! ! This is a very simple test that just tests that the contents/envelope ! routines can be called. This should be upgraded to test the new ! MPI-2 datatype routines (which use address-sized integers) ! errs = 0 call mtest_init( ierr ) call explore( MPI_INTEGER, MPI_COMBINER_NAMED, errs ) call explore( MPI_BYTE, MPI_COMBINER_NAMED, errs ) call mpi_type_vector( 10, 1, 30, MPI_DOUBLE_PRECISION, ntype1, & & ierr ) call explore( ntype1, MPI_COMBINER_VECTOR, errs ) call mpi_type_dup( ntype1, ntype2, ierr ) call explore( ntype2, MPI_COMBINER_DUP, errs ) call mpi_type_free( ntype2, ierr ) call mpi_type_free( ntype1, ierr ) ! call mtest_finalize( errs ) call mpi_finalize( ierr ) end ! subroutine explore( dtype, mycomb, errs ) use mpi integer dtype, mycomb, errs integer ierr integer nints, nadds, ntype, combiner integer max_nints, max_dtypes, max_asizev parameter (max_nints = 10, max_dtypes = 10, max_asizev=10) integer intv(max_nints), dtypesv(max_dtypes) integer (kind=MPI_ADDRESS_KIND) aintv(max_asizev) ! call mpi_type_get_envelope( dtype, nints, nadds, ntype, & & combiner, ierr ) ! if (combiner .ne. MPI_COMBINER_NAMED) then call mpi_type_get_contents( dtype, & & max_nints, max_asizev, max_dtypes, & & intv, aintv, dtypesv, ierr ) ! ! dtypesv of constructed types must be free'd now ! if (combiner .eq. MPI_COMBINER_DUP) then call mpi_type_free( dtypesv(1), ierr ) endif endif if (combiner .ne. mycomb) then errs = errs + 1 print *, ' Expected combiner ', mycomb, ' but got ', & & combiner endif ! ! List all combiner types to check that they are defined in mpif.h if (combiner .eq. MPI_COMBINER_NAMED) then else if (combiner .eq. MPI_COMBINER_DUP) then else if (combiner .eq. MPI_COMBINER_CONTIGUOUS) then else if (combiner .eq. MPI_COMBINER_VECTOR) then else if (combiner .eq. MPI_COMBINER_HVECTOR_INTEGER) then else if (combiner .eq. MPI_COMBINER_HVECTOR) then else if (combiner .eq. MPI_COMBINER_INDEXED) then else if (combiner .eq. MPI_COMBINER_HINDEXED_INTEGER) then else if (combiner .eq. MPI_COMBINER_HINDEXED) then else if (combiner .eq. MPI_COMBINER_INDEXED_BLOCK) then else if (combiner .eq. MPI_COMBINER_STRUCT_INTEGER) then else if (combiner .eq. MPI_COMBINER_STRUCT) then else if (combiner .eq. MPI_COMBINER_SUBARRAY) then else if (combiner .eq. MPI_COMBINER_DARRAY) then else if (combiner .eq. MPI_COMBINER_F90_REAL) then else if (combiner .eq. MPI_COMBINER_F90_COMPLEX) then else if (combiner .eq. MPI_COMBINER_F90_INTEGER) then else if (combiner .eq. MPI_COMBINER_RESIZED) then else errs = errs + 1 print *, ' Unknown combiner ', combiner endif return end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/get_elem_d.f90000644 001750 001750 00000006506 12342443662 024003 0ustar00cici000000 000000 ! -*- Mode: Fortran; -*- ! ! (C) 2013 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! Based on a test written by Jim Hoekstra on behalf of Cray, Inc. ! see ticket #884 https://trac.mpich.org/projects/mpich/ticket/884 program get_elem_d use mpi ! implicit none integer, parameter :: verbose=0 integer, parameter :: cmax=100,dmax=100,imax=60 integer, parameter :: nb=2 integer :: comm,rank,size,dest,ierror,errs=0 integer :: status(MPI_STATUS_SIZE) integer :: i,ii,count,ka,j,jj,k,kj,krat,tag=100 integer :: blklen(nb)=(/2,2/) integer :: types(nb)=(/MPI_DOUBLE_PRECISION,MPI_INTEGER/) integer(kind=MPI_ADDRESS_KIND) :: disp(nb) integer :: newtype,ntlen,ians(0:23),ians0(0:3),ians1(20),ians2(20) double precision :: dbuff(dmax), a integer :: ibuff(imax) character :: cbuff(cmax)='X' call MPI_Init(ierror) comm=MPI_COMM_WORLD call MPI_Comm_size(comm, size, ierror) dest=size-1 call MPI_Comm_rank(comm, rank, ierror) call MPI_Sizeof (j, kj, ierror) call MPI_Sizeof (a, ka, ierror) ntlen=2*ka+2*kj krat=ntlen/kj disp=(/0,2*ka/) ! calculate answers for expected i values for Get_elements with derived type ians0(0)=ka ians0(1)=2*ka ians0(2)=2*ka+kj ians0(3)=2*ka+2*kj ii=0 do i=1,24 if (i .eq. ians0(ii)) ii=ii+1 ians1(i)=ii enddo if (rank == 0 .and. verbose > 0) print *, (ians1(k),k=1,24) jj=0 do j=0,19,4 ians(j)=jj+ka/kj ians(j+1)=jj+2*(ka/kj) ians(j+2)=jj+2*(ka/kj)+1 ians(j+3)=jj+2*(ka/kj)+2 if (rank == 0 .and. verbose > 0) print *, (ians(k),k=j,j+3) jj=jj+ntlen/kj enddo ii=0 do i=1,20 if (i .eq. ians(ii)) ii=ii+1 ians2(i)=ii enddo if (rank == 0 .and. verbose > 0) print *, (ians2(k),k=1,20) if (verbose > 0) print *, MPI_UNDEFINED call MPI_Type_create_struct(nb, blklen, disp, types, newtype, ierror) call MPI_Type_commit(newtype, ierror) do i=1,24 if (rank == 0) then call MPI_Send(cbuff, i, MPI_BYTE, dest, 100, comm, ierror) else if (rank == dest) then ! first receive call MPI_Recv(dbuff, dmax, newtype, 0, 100, comm, status, ierror) ! check on MPI_Get_elements call MPI_Get_elements(status, newtype, count, ierror) if (count .ne. ians1(i)) then errs=errs+1 write (*,fmt="(i2,' R1 Get_elements count=',i3,& &' but should be ',i3)") i,count,ians1(i) endif else ! other ranks do not participate endif enddo do i=1,20 if (rank == 0) then call MPI_Send(ibuff, i, MPI_INTEGER, dest, 100, comm, ierror) else if (rank == dest) then ! second receive call MPI_Recv(dbuff, dmax, newtype, 0, 100, comm, status, ierror) ! check on MPI_Get_elements call MPI_Get_elements(status, newtype, count, ierror) if (count .ne. ians2(i)) then errs=errs+1 write (*,fmt="(i2,' R2 Get_elements count=',i3,& &' but should be ',i3)") i,count,ians2(i) endif else ! other ranks do not participate endif enddo if (rank .eq. dest) then if (errs .eq. 0) then write (*,*) " No Errors" else print *, 'errs=',errs endif endif call MPI_Type_free(newtype, ierror) call MPI_Finalize(ierror) end program get_elem_d SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/gaddressf90.f90000644 001750 001750 00000001773 12342443662 024033 0ustar00cici000000 000000 ! This file created from test/mpi/f77/datatype/gaddressf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer max_asizev parameter (max_asizev=2) integer (kind=MPI_ADDRESS_KIND) aintv(max_asizev), gap integer iarray(200), intsize integer ierr, errs errs = 0 call MPI_Init(ierr) call MPI_Get_address( iarray(1), aintv(1), ierr ) call MPI_Get_address( iarray(200), aintv(2), ierr ) gap = aintv(2) - aintv(1) call MPI_Type_size( MPI_INTEGER, intsize, ierr ) if (gap .ne. 199 * intsize) then errs = errs + 1 print *, ' Using get_address, computed a gap of ', gap print *, ' Expected a gap of ', 199 * intsize endif if (errs .gt. 0) then print *, ' Found ', errs, ' errors' else print *, ' No Errors' endif call MPI_Finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/datatype/CMakeLists.txt000644 001750 001750 00000006654 12342443654 024144 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite AND SMPI_F90) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpif90") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") # add_executable(allctypesf90 allctypesf90.f90) # add_executable(createf90 createf90.f90) add_executable(gaddressf90 gaddressf90.f90) # add_executable(get_elem_d get_elem_d.f90) # add_executable(get_elem_u get_elem_u.f90) # add_executable(hindex1f90 hindex1f90.f90) # add_executable(hindexed_blockf90 hindexed_blockf90.f90) add_executable(indtype indtype.f90) add_executable(kinds kinds.f90) # add_executable(packef90 packef90.f90) # add_executable(sizeof sizeof.f90) # add_executable(structf structf.f90) # add_executable(trf90 trf90.f90) # add_executable(typecntsf90 typecntsf90.f90) # add_executable(typem2f90 typem2f90.f90) # add_executable(typename3f90 typename3f90.f90) # add_executable(typenamef90 typenamef90.f90) # add_executable(typesnamef90 typesnamef90.f90) # add_executable(typesubf90 typesubf90.f90) # target_link_libraries(allctypesf90 simgrid mtest_f90) # target_link_libraries(createf90 simgrid mtest_f90) target_link_libraries(gaddressf90 simgrid mtest_f90) # target_link_libraries(get_elem_d simgrid mtest_f90) # target_link_libraries(get_elem_u simgrid mtest_f90) # target_link_libraries(hindex1f90 simgrid mtest_f90) # target_link_libraries(hindexed_blockf90 simgrid mtest_f90) target_link_libraries(indtype simgrid mtest_f90) target_link_libraries(kinds simgrid mtest_f90) # target_link_libraries(packef90 simgrid mtest_f90) # target_link_libraries(sizeof simgrid mtest_f90) # target_link_libraries(structf simgrid mtest_f90) # target_link_libraries(trf90 simgrid mtest_f90) # target_link_libraries(typecntsf90 simgrid mtest_f90) # target_link_libraries(typem2f90 simgrid mtest_f90) # target_link_libraries(typename3f90 simgrid mtest_f90) # target_link_libraries(typenamef90 simgrid mtest_f90) # target_link_libraries(typesnamef90 simgrid mtest_f90) # target_link_libraries(typesubf90 simgrid mtest_f90) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/allctypesf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/createf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/gaddressf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/get_elem_d.f90 ${CMAKE_CURRENT_SOURCE_DIR}/get_elem_u.f90 ${CMAKE_CURRENT_SOURCE_DIR}/hindex1f90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/hindexed_blockf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/indtype.f90 ${CMAKE_CURRENT_SOURCE_DIR}/kinds.f90 ${CMAKE_CURRENT_SOURCE_DIR}/packef90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/sizeof.f90 ${CMAKE_CURRENT_SOURCE_DIR}/structf.f90 ${CMAKE_CURRENT_SOURCE_DIR}/trf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/typecntsf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/typem2f90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/typename3f90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/typenamef90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/typesnamef90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/typesubf90.f90 PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/000755 001750 001750 00000000000 12342443666 020512 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/allredopttf90.f90000644 001750 001750 00000002703 12342443662 023521 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/allredopttf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2007 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer*8 inbuf, outbuf double complex zinbuf, zoutbuf integer wsize integer errs, ierr errs = 0 call mtest_init( ierr ) call mpi_comm_size( MPI_COMM_WORLD, wsize, ierr ) ! ! A simple test of allreduce for the optional integer*8 type inbuf = 1 outbuf = 0 call mpi_allreduce(inbuf, outbuf, 1, MPI_INTEGER8, MPI_SUM, & & MPI_COMM_WORLD, ierr) if (outbuf .ne. wsize ) then errs = errs + 1 print *, "result wrong for sum with integer*8 = got ", outbuf, & & " but should have ", wsize endif zinbuf = (1,1) zoutbuf = (0,0) call mpi_allreduce(zinbuf, zoutbuf, 1, MPI_DOUBLE_COMPLEX, & & MPI_SUM, MPI_COMM_WORLD, ierr) if (dreal(zoutbuf) .ne. wsize ) then errs = errs + 1 print *, "result wrong for sum with double complex = got ", & & outbuf, " but should have ", wsize endif if (dimag(zoutbuf) .ne. wsize ) then errs = errs + 1 print *, "result wrong for sum with double complex = got ", & & outbuf, " but should have ", wsize endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/testlist000644 001750 001750 00000000476 12342443666 022317 0ustar00cici000000 000000 # This file generated by f77tof90 uallreducef90 4 exscanf90 5 #alltoallwf90 7 alltoallvf90 7 inplacef90 4 reducelocalf90 2 mpiversion=2.2 redscatf90 4 split_typef90 4 mpiversion=3.0 #nonblockingf90 4 mpiversion=3.0 vw_inplacef90 4 mpiversion=2.2 red_scat_blockf90 4 mpiversion=2.2 #nonblocking_inpf90 4 mpiversion=3.0 SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/alltoallvf90.f90000644 001750 001750 00000011137 12342443662 023342 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/alltoallvf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2011 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer ierr, errs integer i, ans, size, rank, color, comm, newcomm integer maxSize, displ parameter (maxSize=128) integer scounts(maxSize), sdispls(maxSize), stypes(maxSize) integer rcounts(maxSize), rdispls(maxSize), rtypes(maxSize) integer sbuf(maxSize), rbuf(maxSize) errs = 0 call mtest_init( ierr ) ! Get a comm call mpi_comm_dup( MPI_COMM_WORLD, comm, ierr ) call mpi_comm_size( comm, size, ierr ) if (size .gt. maxSize) then call mpi_comm_rank( comm, rank, ierr ) color = 1 if (rank .lt. maxSize) color = 0 call mpi_comm_split( comm, color, rank, newcomm, ierr ) call mpi_comm_free( comm, ierr ) comm = newcomm call mpi_comm_size( comm, size, ierr ) endif call mpi_comm_rank( comm, rank, ierr ) ! if (size .le. maxSize) then ! Initialize the data. Just use this as an all to all ! Use the same test as alltoallwf.c , except displacements are in units of ! integers instead of bytes do i=1, size scounts(i) = 1 sdispls(i) = (i-1) stypes(i) = MPI_INTEGER sbuf(i) = rank * size + i rcounts(i) = 1 rdispls(i) = (i-1) rtypes(i) = MPI_INTEGER rbuf(i) = -1 enddo call mpi_alltoallv( sbuf, scounts, sdispls, stypes, & & rbuf, rcounts, rdispls, rtypes, comm, ierr ) ! ! check rbuf(i) = data from the ith location of the ith send buf, or ! rbuf(i) = (i-1) * size + i do i=1, size ans = (i-1) * size + rank + 1 if (rbuf(i) .ne. ans) then errs = errs + 1 print *, rank, ' rbuf(', i, ') = ', rbuf(i), & & ' expected ', ans endif enddo ! ! A halo-exchange example - mostly zero counts ! do i=1, size scounts(i) = 0 sdispls(i) = 0 stypes(i) = MPI_INTEGER sbuf(i) = -1 rcounts(i) = 0 rdispls(i) = 0 rtypes(i) = MPI_INTEGER rbuf(i) = -1 enddo ! ! Note that the arrays are 1-origin displ = 0 if (rank .gt. 0) then scounts(1+rank-1) = 1 rcounts(1+rank-1) = 1 sdispls(1+rank-1) = displ rdispls(1+rank-1) = rank - 1 sbuf(1+displ) = rank displ = displ + 1 endif scounts(1+rank) = 1 rcounts(1+rank) = 1 sdispls(1+rank) = displ rdispls(1+rank) = rank sbuf(1+displ) = rank displ = displ + 1 if (rank .lt. size-1) then scounts(1+rank+1) = 1 rcounts(1+rank+1) = 1 sdispls(1+rank+1) = displ rdispls(1+rank+1) = rank+1 sbuf(1+displ) = rank displ = displ + 1 endif call mpi_alltoallv( sbuf, scounts, sdispls, stypes, & & rbuf, rcounts, rdispls, rtypes, comm, ierr ) ! ! Check the neighbor values are correctly moved ! if (rank .gt. 0) then if (rbuf(1+rank-1) .ne. rank-1) then errs = errs + 1 print *, rank, ' rbuf(',1+rank-1, ') = ', rbuf(1+rank-1), & & 'expected ', rank-1 endif endif if (rbuf(1+rank) .ne. rank) then errs = errs + 1 print *, rank, ' rbuf(', 1+rank, ') = ', rbuf(1+rank), & & 'expected ', rank endif if (rank .lt. size-1) then if (rbuf(1+rank+1) .ne. rank+1) then errs = errs + 1 print *, rank, ' rbuf(', 1+rank+1, ') = ',rbuf(1+rank+1), & & 'expected ', rank+1 endif endif do i=0,rank-2 if (rbuf(1+i) .ne. -1) then errs = errs + 1 print *, rank, ' rbuf(', 1+i, ') = ', rbuf(1+i), & & 'expected -1' endif enddo do i=rank+2,size-1 if (rbuf(1+i) .ne. -1) then errs = errs + 1 print *, rank, ' rbuf(', i, ') = ', rbuf(1+i), & & 'expected -1' endif enddo endif call mpi_comm_free( comm, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/nonblockingf90.f90000644 001750 001750 00000006610 12342443662 023653 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/nonblockingf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2012 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer NUM_INTS parameter (NUM_INTS=2) integer maxSize parameter (maxSize=128) integer scounts(maxSize), sdispls(maxSize) integer rcounts(maxSize), rdispls(maxSize) integer types(maxSize) integer sbuf(maxSize), rbuf(maxSize) integer comm, size, rank, req integer ierr, errs integer ii, ans errs = 0 call mtest_init(ierr) comm = MPI_COMM_WORLD call MPI_Comm_size(comm, size, ierr) call MPI_Comm_rank(comm, rank, ierr) ! do ii = 1, size sbuf(2*ii-1) = ii sbuf(2*ii) = ii sbuf(2*ii-1) = ii sbuf(2*ii) = ii scounts(ii) = NUM_INTS rcounts(ii) = NUM_INTS sdispls(ii) = (ii-1) * NUM_INTS rdispls(ii) = (ii-1) * NUM_INTS types(ii) = MPI_INTEGER enddo call MPI_Ibarrier(comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ibcast(sbuf, NUM_INTS, MPI_INTEGER, 0, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Igather(sbuf, NUM_INTS, MPI_INTEGER, & & rbuf, NUM_INTS, MPI_INTEGER, & & 0, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Igatherv(sbuf, NUM_INTS, MPI_INTEGER, & & rbuf, rcounts, rdispls, MPI_INTEGER, & & 0, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ialltoall(sbuf, NUM_INTS, MPI_INTEGER, & & rbuf, NUM_INTS, MPI_INTEGER, & & comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ialltoallv(sbuf, scounts, sdispls, MPI_INTEGER, & & rbuf, rcounts, rdispls, MPI_INTEGER, & & comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ialltoallw(sbuf, scounts, sdispls, types, & & rbuf, rcounts, rdispls, types, & & comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ireduce(sbuf, rbuf, NUM_INTS, MPI_INTEGER, & & MPI_SUM, 0, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Iallreduce(sbuf, rbuf, NUM_INTS, MPI_INTEGER, & & MPI_SUM, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ireduce_scatter(sbuf, rbuf, rcounts, MPI_INTEGER, & & MPI_SUM, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Ireduce_scatter_block(sbuf, rbuf, NUM_INTS, MPI_INTEGER, & & MPI_SUM, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Iscan(sbuf, rbuf, NUM_INTS, MPI_INTEGER, & & MPI_SUM, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call MPI_Iexscan(sbuf, rbuf, NUM_INTS, MPI_INTEGER, & & MPI_SUM, comm, req, ierr) call MPI_Wait(req, MPI_STATUS_IGNORE, ierr) call mtest_finalize( errs ) call MPI_Finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/alltoallwf90.f90000644 001750 001750 00000004205 12342443662 023341 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/alltoallwf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer ierr, errs integer i, intsize, ans, size, rank, color, comm, newcomm integer maxSize parameter (maxSize=32) integer scounts(maxSize), sdispls(maxSize), stypes(maxSize) integer rcounts(maxSize), rdispls(maxSize), rtypes(maxSize) integer sbuf(maxSize), rbuf(maxSize) errs = 0 call mtest_init( ierr ) call mpi_type_size( MPI_INTEGER, intsize, ierr ) ! Get a comm call mpi_comm_dup( MPI_COMM_WORLD, comm, ierr ) call mpi_comm_size( comm, size, ierr ) if (size .gt. maxSize) then call mpi_comm_rank( comm, rank, ierr ) color = 1 if (rank .lt. maxSize) color = 0 call mpi_comm_split( comm, color, rank, newcomm, ierr ) call mpi_comm_free( comm, ierr ) comm = newcomm call mpi_comm_size( comm, size, ierr ) endif call mpi_comm_rank( comm, rank, ierr ) if (size .le. maxSize) then ! Initialize the data. Just use this as an all to all do i=1, size scounts(i) = 1 sdispls(i) = (i-1)*intsize stypes(i) = MPI_INTEGER sbuf(i) = rank * size + i rcounts(i) = 1 rdispls(i) = (i-1)*intsize rtypes(i) = MPI_INTEGER rbuf(i) = -1 enddo call mpi_alltoallw( sbuf, scounts, sdispls, stypes, & & rbuf, rcounts, rdispls, rtypes, comm, ierr ) ! ! check rbuf(i) = data from the ith location of the ith send buf, or ! rbuf(i) = (i-1) * size + i do i=1, size ans = (i-1) * size + rank + 1 if (rbuf(i) .ne. ans) then errs = errs + 1 print *, rank, ' rbuf(', i, ') = ', rbuf(i), & & ' expected ', ans endif enddo endif call mpi_comm_free( comm, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/vw_inplacef90.f90000644 001750 001750 00000007047 12342443662 023504 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/vw_inplacef.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2012 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! A simple test for Fortran support of the MPI_IN_PLACE value in Alltoall[vw]. ! program main use mpi integer SIZEOFINT integer MAX_SIZE parameter (MAX_SIZE=1024) integer rbuf(MAX_SIZE) integer rdispls(MAX_SIZE), rcounts(MAX_SIZE), rtypes(MAX_SIZE) integer ierr, errs integer comm integer rank, size integer iexpected, igot integer i, j errs = 0 call mtest_init( ierr ) comm = MPI_COMM_WORLD call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) call mpi_type_size( MPI_INTEGER, SIZEOFINT, ierr ) if (size .gt. MAX_SIZE) then print *, ' At most ', MAX_SIZE, ' processes allowed' call mpi_abort( MPI_COMM_WORLD, 1, ierr ) endif ! do i=1,MAX_SIZE rbuf(i) = -1 enddo do i=1,size rbuf(i) = (i-1) * size + rank enddo call mpi_alltoall( MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, & & rbuf, 1, MPI_INTEGER, comm, ierr ) do i=1,size if (rbuf(i) .ne. (rank*size + i - 1)) then errs = errs + 1 print *, '[', rank, '] rbuf(', i, ') = ', rbuf(i), & & ', should be', rank * size + i - 1 endif enddo do i=1,MAX_SIZE rbuf(i) = -1 enddo do i=1,size rcounts(i) = (i-1) + rank rdispls(i) = (i-1) * (2*size) do j=0,rcounts(i)-1 rbuf(rdispls(i)+j+1) = 100 * rank + 10 * (i-1) + j enddo enddo call mpi_alltoallv( MPI_IN_PLACE, 0, 0, MPI_DATATYPE_NULL, & & rbuf, rcounts, rdispls, MPI_INTEGER, & & comm, ierr ) do i=1,size do j=0,rcounts(i)-1 iexpected = 100 * (i-1) + 10 * rank + j igot = rbuf(rdispls(i)+j+1) if ( igot .ne. iexpected ) then errs = errs + 1 print *, '[', rank, '] ALLTOALLV got ', igot, & & ',but expected ', iexpected, & & ' for block=', i-1, ' element=', j endif enddo enddo do i=1,MAX_SIZE rbuf(i) = -1 enddo ! Alltoallw's displs[] are in bytes not in type extents. do i=1,size rcounts(i) = (i-1) + rank rdispls(i) = (i-1) * (2*size) * SIZEOFINT rtypes(i) = MPI_INTEGER do j=0,rcounts(i)-1 rbuf(rdispls(i)/SIZEOFINT+j+1) = 100 * rank & & + 10 * (i-1) + j enddo enddo call mpi_alltoallw( MPI_IN_PLACE, 0, 0, MPI_DATATYPE_NULL, & & rbuf, rcounts, rdispls, rtypes, & & comm, ierr ) do i=1,size do j=0,rcounts(i)-1 iexpected = 100 * (i-1) + 10 * rank + j igot = rbuf(rdispls(i)/SIZEOFINT+j+1) if ( igot .ne. iexpected ) then errs = errs + 1 print *, '[', rank, '] ALLTOALLW got ', igot, & & ',but expected ', iexpected, & & ' for block=', i-1, ' element=', j endif enddo enddo call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/redscatf90.f90000644 001750 001750 00000004727 12342443662 023004 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/redscatf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2011 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! subroutine uop( cin, cout, count, datatype ) use mpi integer cin(*), cout(*) integer count, datatype integer i if (.false.) then if (datatype .ne. MPI_INTEGER) then write(6,*) 'Invalid datatype ',datatype,' passed to user_op()' return endif endif do i=1, count cout(i) = cin(i) + cout(i) enddo end ! ! Test of reduce scatter. ! ! Each processor contributes its rank + the index to the reduction, ! then receives the ith sum ! ! Can be called with any number of processors. ! program main use mpi integer errs, ierr integer maxsize parameter (maxsize=1024) integer recvbuf integer size, rank, i, sumval integer comm, sumop external uop integer status integer, dimension(:),allocatable :: sendbuf,recvcounts ALLOCATE(sendbuf(maxsize), STAT=status) ALLOCATE(recvcounts(maxsize), STAT=status) errs = 0 call mtest_init( ierr ) comm = MPI_COMM_WORLD call mpi_comm_size( comm, size, ierr ) call mpi_comm_rank( comm, rank, ierr ) if (size .gt. maxsize) then endif do i=1, size sendbuf(i) = rank + i - 1 recvcounts(i) = 1 enddo call mpi_reduce_scatter( sendbuf, recvbuf, recvcounts, & & MPI_INTEGER, MPI_SUM, comm, ierr ) sumval = size * rank + ((size - 1) * size)/2 ! recvbuf should be size * (rank + i) if (recvbuf .ne. sumval) then errs = errs + 1 print *, "Did not get expected value for reduce scatter" print *, rank, " Got ", recvbuf, " expected ", sumval endif call mpi_op_create( uop, .true., sumop, ierr ) call mpi_reduce_scatter( sendbuf, recvbuf, recvcounts, & & MPI_INTEGER, sumop, comm, ierr ) sumval = size * rank + ((size - 1) * size)/2 ! recvbuf should be size * (rank + i) if (recvbuf .ne. sumval) then errs = errs + 1 print *, "sumop: Did not get expected value for reduce scatter" print *, rank, " Got ", recvbuf, " expected ", sumval endif call mpi_op_free( sumop, ierr ) DEALLOCATE(sendbuf) DEALLOCATE(recvcounts) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/allredint8f90.f90000644 001750 001750 00000001123 12342443662 023410 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/allredint8f.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2006 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer*8 inbuf, outbuf integer errs, ierr errs = 0 call mtest_init( ierr ) ! ! A simple test of allreduce for the optional integer*8 type call mpi_allreduce(inbuf, outbuf, 1, MPI_INTEGER8, MPI_SUM, & & MPI_COMM_WORLD, ierr) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/inplacef90.f90000644 001750 001750 00000005221 12342443662 022760 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/inplacef.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2005 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! This is a simple test that Fortran support the MPI_IN_PLACE value ! program main use mpi integer ierr, errs integer comm, root integer rank, size integer i integer MAX_SIZE parameter (MAX_SIZE=1024) integer rbuf(MAX_SIZE), rdispls(MAX_SIZE), rcount(MAX_SIZE), & & sbuf(MAX_SIZE) errs = 0 call mtest_init( ierr ) comm = MPI_COMM_WORLD call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) root = 0 ! Gather with inplace do i=1,size rbuf(i) = - i enddo rbuf(1+root) = root if (rank .eq. root) then call mpi_gather( MPI_IN_PLACE, 1, MPI_INTEGER, rbuf, 1, & & MPI_INTEGER, root, comm, ierr ) do i=1,size if (rbuf(i) .ne. i-1) then errs = errs + 1 print *, '[',rank,'] rbuf(', i, ') = ', rbuf(i), & & ' in gather' endif enddo else call mpi_gather( rank, 1, MPI_INTEGER, rbuf, 1, MPI_INTEGER, & & root, comm, ierr ) endif ! Gatherv with inplace do i=1,size rbuf(i) = - i rcount(i) = 1 rdispls(i) = i-1 enddo rbuf(1+root) = root if (rank .eq. root) then call mpi_gatherv( MPI_IN_PLACE, 1, MPI_INTEGER, rbuf, rcount, & & rdispls, MPI_INTEGER, root, comm, ierr ) do i=1,size if (rbuf(i) .ne. i-1) then errs = errs + 1 print *, '[', rank, '] rbuf(', i, ') = ', rbuf(i), & & ' in gatherv' endif enddo else call mpi_gatherv( rank, 1, MPI_INTEGER, rbuf, rcount, rdispls, & & MPI_INTEGER, root, comm, ierr ) endif ! Scatter with inplace do i=1,size sbuf(i) = i enddo rbuf(1) = -1 if (rank .eq. root) then call mpi_scatter( sbuf, 1, MPI_INTEGER, MPI_IN_PLACE, 1, & & MPI_INTEGER, root, comm, ierr ) else call mpi_scatter( sbuf, 1, MPI_INTEGER, rbuf, 1, & & MPI_INTEGER, root, comm, ierr ) if (rbuf(1) .ne. rank+1) then errs = errs + 1 print *, '[', rank, '] rbuf = ', rbuf(1), & & ' in scatter' endif endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/red_scat_blockf90.f90000644 001750 001750 00000003300 12342443662 024277 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/red_scat_blockf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2012 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! A simple test for Fortran support of Reduce_scatter_block ! with or withoutMPI_IN_PLACE. ! program main use mpi integer MAX_SIZE parameter (MAX_SIZE=1024) integer sbuf(MAX_SIZE), rbuf(MAX_SIZE) integer comm, rank, size integer sumval, ierr, errs, i errs = 0 call mtest_init( ierr ) comm = MPI_COMM_WORLD call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) do i = 1, size sbuf(i) = rank + (i-1) enddo call MPI_Reduce_scatter_block(sbuf, rbuf, 1, MPI_INTEGER, & & MPI_SUM, comm, ierr) sumval = size * rank + ((size-1) * size)/2 if ( rbuf(1) .ne. sumval ) then errs = errs + 1 print *, 'Reduce_scatter_block does not get expected value.' print *, '[', rank, ']', 'Got ', rbuf(1), ' but expected ', & & sumval, '.' endif ! Try MPI_IN_PLACE do i = 1, size rbuf(i) = rank + (i-1) enddo call MPI_Reduce_scatter_block(MPI_IN_PLACE, rbuf, 1, MPI_INTEGER, & & MPI_SUM, comm, ierr) if ( rbuf(1) .ne. sumval ) then errs = errs + 1 print *, 'Reduce_scatter_block does not get expected value.' print *, '[', rank, ']', 'Got ', rbuf(1), ' but expected ', & & sumval, '.' endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/exscanf90.f90000644 001750 001750 00000006366 12342443662 022641 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/exscanf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! subroutine uop( cin, cout, count, datatype ) use mpi integer cin(*), cout(*) integer count, datatype integer i if (.false.) then if (datatype .ne. MPI_INTEGER) then write(6,*) 'Invalid datatype passed to user_op()' return endif endif do i=1, count cout(i) = cin(i) + cout(i) enddo end ! program main use mpi integer, dimension(:), allocatable :: inbuf, outbuf integer ans, rank, size, comm integer errs, ierr integer sumop, status external uop allocate(inbuf(2), STAT=status) allocate(outbuf(2), STAT=status) errs = 0 call mtest_init( ierr ) ! ! A simple test of exscan comm = MPI_COMM_WORLD call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) inbuf(1) = rank inbuf(2) = -rank call mpi_exscan( inbuf, outbuf, 2, MPI_INTEGER, MPI_SUM, comm, & & ierr ) ! this process has the sum of i from 0 to rank-1, which is ! (rank)(rank-1)/2 and -i ans = (rank * (rank - 1))/2 if (rank .gt. 0) then if (outbuf(1) .ne. ans) then errs = errs + 1 print *, rank, ' Expected ', ans, ' got ', outbuf(1) endif if (outbuf(2) .ne. -ans) then errs = errs + 1 print *, rank, ' Expected ', -ans, ' got ', outbuf(1) endif endif ! ! Try a user-defined operation ! call mpi_op_create( uop, .true., sumop, ierr ) inbuf(1) = rank inbuf(2) = -rank call mpi_exscan( inbuf, outbuf, 2, MPI_INTEGER, sumop, comm, & & ierr ) ! this process has the sum of i from 0 to rank-1, which is ! (rank)(rank-1)/2 and -i ans = (rank * (rank - 1))/2 if (rank .gt. 0) then if (outbuf(1) .ne. ans) then errs = errs + 1 print *, rank, ' sumop: Expected ', ans, ' got ', outbuf(1) endif if (outbuf(2) .ne. -ans) then errs = errs + 1 print *, rank, ' sumop: Expected ', -ans, ' got ', outbuf(1) endif endif call mpi_op_free( sumop, ierr ) ! ! Try a user-defined operation (and don't claim it is commutative) ! call mpi_op_create( uop, .false., sumop, ierr ) inbuf(1) = rank inbuf(2) = -rank call mpi_exscan( inbuf, outbuf, 2, MPI_INTEGER, sumop, comm, & & ierr ) ! this process has the sum of i from 0 to rank-1, which is ! (rank)(rank-1)/2 and -i ans = (rank * (rank - 1))/2 if (rank .gt. 0) then if (outbuf(1) .ne. ans) then errs = errs + 1 print *, rank, ' sumop2: Expected ', ans, ' got ', outbuf(1) endif if (outbuf(2) .ne. -ans) then errs = errs + 1 print *, rank, ' sumop2: Expected ', -ans, ' got ',outbuf(1) endif endif call mpi_op_free( sumop, ierr ) deallocate(inbuf) deallocate(outbuf) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/nonblocking_inpf90.f90000644 001750 001750 00000010300 12342443662 024510 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/nonblocking_inpf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2012 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! A simple test for Fortran support of the MPI_IN_PLACE value in Alltoall[vw]. ! program main use mpi integer SIZEOFINT integer MAX_SIZE parameter (MAX_SIZE=1024) integer rbuf(MAX_SIZE) integer rdispls(MAX_SIZE), rcounts(MAX_SIZE), rtypes(MAX_SIZE) integer comm, rank, size, req integer sumval, ierr, errs integer iexpected, igot integer i, j errs = 0 call mtest_init( ierr ) comm = MPI_COMM_WORLD call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) call mpi_type_size( MPI_INTEGER, SIZEOFINT, ierr ) do i=1,MAX_SIZE rbuf(i) = -1 enddo do i=1,size rbuf(i) = (i-1) * size + rank enddo call mpi_ialltoall( MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, & & rbuf, 1, MPI_INTEGER, comm, req, ierr ) call mpi_wait( req, MPI_STATUS_IGNORE, ierr ) do i=1,size if (rbuf(i) .ne. (rank*size + i - 1)) then errs = errs + 1 print *, '[', rank, ']: IALLTOALL rbuf(', i, ') = ', & & rbuf(i), ', should be', rank * size + i - 1 endif enddo do i=1,MAX_SIZE rbuf(i) = -1 enddo do i=1,size rcounts(i) = i-1 + rank rdispls(i) = (i-1) * (2*size) do j=0,rcounts(i)-1 rbuf(rdispls(i)+j+1) = 100 * rank + 10 * (i-1) + j enddo enddo call mpi_ialltoallv( MPI_IN_PLACE, 0, 0, MPI_DATATYPE_NULL, & & rbuf, rcounts, rdispls, MPI_INTEGER, & & comm, req, ierr ) call mpi_wait( req, MPI_STATUS_IGNORE, ierr ) do i=1,size do j=0,rcounts(i)-1 iexpected = 100 * (i-1) + 10 * rank + j igot = rbuf(rdispls(i)+j+1) if ( igot .ne. iexpected ) then errs = errs + 1 print *, '[', rank, ']: IALLTOALLV got ', igot, & & ',but expected ', iexpected, & & ' for block=', i-1, ' element=', j endif enddo enddo do i=1,MAX_SIZE rbuf(i) = -1 enddo do i=1,size rcounts(i) = i-1 + rank rdispls(i) = (i-1) * (2*size) * SIZEOFINT rtypes(i) = MPI_INTEGER do j=0,rcounts(i)-1 rbuf(rdispls(i)/SIZEOFINT+j+1) = 100 * rank & & + 10 * (i-1) + j enddo enddo call mpi_ialltoallw( MPI_IN_PLACE, 0, 0, MPI_DATATYPE_NULL, & & rbuf, rcounts, rdispls, rtypes, & & comm, req, ierr ) call mpi_wait( req, MPI_STATUS_IGNORE, ierr ) do i=1,size do j=0,rcounts(i)-1 iexpected = 100 * (i-1) + 10 * rank + j igot = rbuf(rdispls(i)/SIZEOFINT+j+1) if ( igot .ne. iexpected ) then errs = errs + 1 print *, '[', rank, ']: IALLTOALLW got ', igot, & & ',but expected ', iexpected, & & ' for block=', i-1, ' element=', j endif enddo enddo do i=1,MAX_SIZE rbuf(i) = -1 enddo do i = 1, size rbuf(i) = rank + (i-1) enddo call mpi_ireduce_scatter_block( MPI_IN_PLACE, rbuf, 1, & & MPI_INTEGER, MPI_SUM, comm, & & req, ierr ) call mpi_wait( req, MPI_STATUS_IGNORE, ierr ) sumval = size * rank + ((size-1) * size)/2 if ( rbuf(1) .ne. sumval ) then errs = errs + 1 print *, 'Ireduce_scatter_block does not get expected value.' print *, '[', rank, ']:', 'Got ', rbuf(1), ' but expected ', & & sumval, '.' endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/uallreducef90.f90000644 001750 001750 00000003406 12342443662 023475 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/uallreducef.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! ! Test user-defined operations. This tests a simple commutative operation ! subroutine uop( cin, cout, count, datatype ) use mpi integer cin(*), cout(*) integer count, datatype integer i if (datatype .eq. MPI_INTEGER) then print *, 'Invalid datatype (',datatype,') passed to user_op()' return endif do i=1, count cout(i) = cin(i) + cout(i) enddo end program main use mpi external uop integer ierr, errs integer count, sumop, i, size integer, DIMENSION(:), ALLOCATABLE :: vin, vout integer comm integer status errs = 0 ALLOCATE(vin(65000), STAT=status) ALLOCATE(vout(65000), STAT=status) call mtest_init(ierr) call mpi_op_create( uop, .true., sumop, ierr ) comm = MPI_COMM_WORLD call mpi_comm_size( comm, size, ierr ) count = 1 do while (count .lt. 65000) do i=1, count vin(i) = i vout(i) = -1 enddo call mpi_allreduce( vin, vout, count, MPI_INTEGER, sumop, & & comm, ierr ) ! Check that all results are correct do i=1, count if (vout(i) .ne. i * size) then errs = errs + 1 if (errs .lt. 10) print *, "vout(",i,") = ", vout(i) endif enddo count = count + count enddo call mpi_op_free( sumop, ierr ) DEALLOCATE(vout) DEALLOCATE(vin) call mtest_finalize(errs) call mpi_finalize(ierr) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/reducelocalf90.f90000644 001750 001750 00000004603 12342443662 023632 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/reducelocalf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2009 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! ! Test Fortran MPI_Reduce_local with MPI_OP_SUM and with user-defined operation. ! subroutine user_op( invec, outvec, count, datatype ) use mpi integer invec(*), outvec(*) integer count, datatype integer ii if (datatype .ne. MPI_INTEGER) then write(6,*) 'Invalid datatype passed to user_op()' return endif do ii=1, count outvec(ii) = invec(ii) * 2 + outvec(ii) enddo end program main use mpi integer max_buf_size parameter (max_buf_size=65000) integer vin(max_buf_size), vout(max_buf_size) external user_op integer ierr, errs integer count, myop integer ii errs = 0 call mtest_init(ierr) count = 0 do while (count .le. max_buf_size ) do ii = 1,count vin(ii) = ii vout(ii) = ii enddo call mpi_reduce_local( vin, vout, count, & & MPI_INTEGER, MPI_SUM, ierr ) ! Check if the result is correct do ii = 1,count if ( vin(ii) .ne. ii ) then errs = errs + 1 endif if ( vout(ii) .ne. 2*ii ) then errs = errs + 1 endif enddo if ( count .gt. 0 ) then count = count + count else count = 1 endif enddo call mpi_op_create( user_op, .false., myop, ierr ) count = 0 do while (count .le. max_buf_size) do ii = 1, count vin(ii) = ii vout(ii) = ii enddo call mpi_reduce_local( vin, vout, count, & & MPI_INTEGER, myop, ierr ) ! Check if the result is correct do ii = 1, count if ( vin(ii) .ne. ii ) then errs = errs + 1 endif if ( vout(ii) .ne. 3*ii ) then errs = errs + 1 endif enddo if ( count .gt. 0 ) then count = count + count else count = 1 endif enddo call mpi_op_free( myop, ierr ) call mtest_finalize(errs) call mpi_finalize(ierr) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/split_typef90.f90000644 001750 001750 00000002527 12342443662 023547 0ustar00cici000000 000000 ! This file created from test/mpi/f77/coll/split_typef.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2011 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer ierr, errs integer i, size, rank, comm, newcomm integer maxSize parameter (maxSize=128) integer scounts(maxSize), sdispls(maxSize), stypes(maxSize) integer rcounts(maxSize), rdispls(maxSize), rtypes(maxSize) integer sbuf(maxSize), rbuf(maxSize) errs = 0 call mtest_init( ierr ) call mpi_comm_dup( MPI_COMM_WORLD, comm, ierr ) call mpi_comm_split_type( comm, MPI_COMM_TYPE_SHARED, rank, & & MPI_INFO_NULL, newcomm, ierr ) call mpi_comm_rank( newcomm, rank, ierr ) call mpi_comm_size( newcomm, size, ierr ) do i=1, size scounts(i) = 1 sdispls(i) = (i-1) stypes(i) = MPI_INTEGER sbuf(i) = rank * size + i rcounts(i) = 1 rdispls(i) = (i-1) rtypes(i) = MPI_INTEGER rbuf(i) = -1 enddo call mpi_alltoallv( sbuf, scounts, sdispls, stypes, & & rbuf, rcounts, rdispls, rtypes, newcomm, ierr ) call mpi_comm_free( newcomm, ierr ) call mpi_comm_free( comm, ierr ) call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/coll/CMakeLists.txt000644 001750 001750 00000005635 12342443654 023260 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite AND SMPI_F90) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpif90") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") # add_executable(allredint8f90 allredint8f90.f90) # add_executable(allredopttf90 allredopttf90.f90) add_executable(alltoallvf90 alltoallvf90.f90) # add_executable(alltoallwf90 alltoallwf90.f90) add_executable(exscanf90 exscanf90.f90) add_executable(inplacef90 inplacef90.f90) # add_executable(nonblockingf90 nonblockingf90.f90) # add_executable(nonblocking_inpf90 nonblocking_inpf90.f90) add_executable(red_scat_blockf90 red_scat_blockf90.f90) add_executable(redscatf90 redscatf90.f90) add_executable(reducelocalf90 reducelocalf90.f90) add_executable(split_typef90 split_typef90.f90) add_executable(uallreducef90 uallreducef90.f90) add_executable(vw_inplacef90 vw_inplacef90.f90) # target_link_libraries(allredint8f90 simgrid mtest_f90) # target_link_libraries(allredopttf90 simgrid mtest_f90) target_link_libraries(alltoallvf90 simgrid mtest_f90) # target_link_libraries(alltoallwf90 simgrid mtest_f90) target_link_libraries(exscanf90 simgrid mtest_f90) target_link_libraries(inplacef90 simgrid mtest_f90) # target_link_libraries(nonblockingf90 simgrid mtest_f90) # target_link_libraries(nonblocking_inpf90 simgrid mtest_f90) target_link_libraries(red_scat_blockf90 simgrid mtest_f90) target_link_libraries(redscatf90 simgrid mtest_f90) target_link_libraries(reducelocalf90 simgrid mtest_f90) target_link_libraries(split_typef90 simgrid mtest_f90) target_link_libraries(uallreducef90 simgrid mtest_f90) target_link_libraries(vw_inplacef90 simgrid mtest_f90) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/allredint8f90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/allredopttf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/alltoallvf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/alltoallwf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/exscanf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/inplacef90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/nonblockingf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/nonblocking_inpf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/red_scat_blockf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/redscatf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/reducelocalf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/split_typef90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/uallreducef90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/vw_inplacef90.f90 PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/pt2pt/000755 001750 001750 00000000000 12342443666 020632 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/pt2pt/testlist000644 001750 001750 00000000143 12342443666 022426 0ustar00cici000000 000000 # This file generated by f77tof90 statusesf90 1 #greqf90 1 allpairf90 2 mprobef90 2 mpiversion=3.0 SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/pt2pt/allpairf90.f90000644 001750 001750 00000072670 12342443662 023125 0ustar00cici000000 000000 ! This file created from test/mpi/f77/pt2pt/allpairf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2012 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! This program is based on the allpair.f test from the MPICH-1 test ! (test/pt2pt/allpair.f), which in turn was inspired by a bug report from ! fsset@corelli.lerc.nasa.gov (Scott Townsend) program allpair use mpi integer ierr, errs, comm logical mtestGetIntraComm logical verbose common /flags/ verbose errs = 0 verbose = .false. ! verbose = .true. call MTest_Init( ierr ) do while ( mtestGetIntraComm( comm, 2, .false. ) ) call test_pair_send( comm, errs ) call test_pair_ssend( comm, errs ) !call test_pair_rsend( comm, errs ) call test_pair_isend( comm, errs ) !call test_pair_irsend( comm, errs ) call test_pair_issend( comm, errs ) call test_pair_psend( comm, errs ) !call test_pair_prsend( comm, errs ) call test_pair_pssend( comm, errs ) call test_pair_sendrecv( comm, errs ) call test_pair_sendrecvrepl( comm, errs ) call mtestFreeComm( comm ) enddo ! call MTest_Finalize( errs ) call MPI_Finalize(ierr) ! end ! subroutine test_pair_send( comm, errs ) use mpi integer comm, errs integer rank, size, ierr, next, prev, tag, count integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE) real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose ! if (verbose) then print *, ' Send and recv' endif ! call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 ! prev = rank - 1 if (prev .lt. 0) prev = size - 1 ! tag = 1123 count = TEST_SIZE / 5 ! call clear_test_data(recv_buf,TEST_SIZE) ! if (rank .eq. 0) then ! call init_test_data(send_buf,TEST_SIZE) ! call MPI_Send(send_buf, count, MPI_REAL, next, tag, & & comm, ierr) ! call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, status, ierr) ! call msg_check( recv_buf, next, tag, count, status, TEST_SIZE, & & 'send and recv', errs ) else if (prev .eq. 0) then call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, status, ierr) call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, & & 'send and recv', errs ) ! call MPI_Send(recv_buf, count, MPI_REAL, prev, tag, comm, ierr) end if ! end ! subroutine test_pair_rsend( comm, errs ) use mpi integer comm, errs integer rank, size, ierr, next, prev, tag, count, i integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE), requests(1) real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose ! if (verbose) then print *, ' Rsend and recv' endif ! ! call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 ! prev = rank - 1 if (prev .lt. 0) prev = size - 1 ! tag = 1456 count = TEST_SIZE / 3 ! call clear_test_data(recv_buf,TEST_SIZE) ! if (rank .eq. 0) then ! call init_test_data(send_buf,TEST_SIZE) ! call MPI_Recv( MPI_BOTTOM, 0, MPI_INTEGER, next, tag, & & comm, status, ierr ) ! call MPI_Rsend(send_buf, count, MPI_REAL, next, tag, & & comm, ierr) ! call MPI_Probe(MPI_ANY_SOURCE, tag, comm, status, ierr) ! if (status(MPI_SOURCE) .ne. next) then print *, 'Rsend: Incorrect source, expected', next, & & ', got', status(MPI_SOURCE) errs = errs + 1 end if ! if (status(MPI_TAG) .ne. tag) then print *, 'Rsend: Incorrect tag, expected', tag, & & ', got', status(MPI_TAG) errs = errs + 1 end if ! call MPI_Get_count(status, MPI_REAL, i, ierr) ! if (i .ne. count) then print *, 'Rsend: Incorrect count, expected', count, & & ', got', i errs = errs + 1 end if ! call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & status, ierr) ! call msg_check( recv_buf, next, tag, count, status, TEST_SIZE, & & 'rsend and recv', errs ) ! else if (prev .eq. 0) then ! call MPI_Irecv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & requests(1), ierr) call MPI_Send( MPI_BOTTOM, 0, MPI_INTEGER, prev, tag, & & comm, ierr ) call MPI_Wait( requests(1), status, ierr ) call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, & & 'rsend and recv', errs ) ! call MPI_Send(recv_buf, count, MPI_REAL, prev, tag, & & comm, ierr) end if ! end ! subroutine test_pair_ssend( comm, errs ) use mpi integer comm, errs integer rank, size, ierr, next, prev, tag, count, i integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE) logical flag real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose ! if (verbose) then print *, ' Ssend and recv' endif ! ! call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 ! prev = rank - 1 if (prev .lt. 0) prev = size - 1 ! tag = 1789 count = TEST_SIZE / 3 ! call clear_test_data(recv_buf,TEST_SIZE) ! if (rank .eq. 0) then ! call init_test_data(send_buf,TEST_SIZE) ! call MPI_Iprobe(MPI_ANY_SOURCE, tag, & & comm, flag, status, ierr) ! if (flag) then print *, 'Ssend: Iprobe succeeded! source', & & status(MPI_SOURCE), & & ', tag', status(MPI_TAG) errs = errs + 1 end if ! call MPI_Ssend(send_buf, count, MPI_REAL, next, tag, & & comm, ierr) ! do while (.not. flag) call MPI_Iprobe(MPI_ANY_SOURCE, tag, & & comm, flag, status, ierr) end do ! if (status(MPI_SOURCE) .ne. next) then print *, 'Ssend: Incorrect source, expected', next, & & ', got', status(MPI_SOURCE) errs = errs + 1 end if ! if (status(MPI_TAG) .ne. tag) then print *, 'Ssend: Incorrect tag, expected', tag, & & ', got', status(MPI_TAG) errs = errs + 1 end if ! call MPI_Get_count(status, MPI_REAL, i, ierr) ! if (i .ne. count) then print *, 'Ssend: Incorrect count, expected', count, & & ', got', i errs = errs + 1 end if ! call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & status, ierr) ! call msg_check( recv_buf, next, tag, count, status, & & TEST_SIZE, 'ssend and recv', errs ) ! else if (prev .eq. 0) then ! call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & status, ierr) ! call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, & & 'ssend and recv', errs ) ! call MPI_Ssend(recv_buf, count, MPI_REAL, prev, tag, & & comm, ierr) end if ! end ! subroutine test_pair_isend( comm, errs ) use mpi integer comm, errs integer rank, size, ierr, next, prev, tag, count integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE), requests(2) integer statuses(MPI_STATUS_SIZE,2) real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose ! if (verbose) then print *, ' isend and irecv' endif ! ! call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 ! prev = rank - 1 if (prev .lt. 0) prev = size - 1 ! tag = 2123 count = TEST_SIZE / 5 ! call clear_test_data(recv_buf,TEST_SIZE) ! if (rank .eq. 0) then ! call MPI_Irecv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & requests(1), ierr) ! call init_test_data(send_buf,TEST_SIZE) ! call MPI_Isend(send_buf, count, MPI_REAL, next, tag, & & comm, requests(2), ierr) ! call MPI_Waitall(2, requests, statuses, ierr) ! call rq_check( requests, 2, 'isend and irecv' ) ! call msg_check( recv_buf, next, tag, count, statuses(1,1), & & TEST_SIZE, 'isend and irecv', errs ) ! else if (prev .eq. 0) then ! call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & status, ierr) ! call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, & & 'isend and irecv', errs ) ! call MPI_Isend(recv_buf, count, MPI_REAL, prev, tag, & & comm, requests(1), ierr) ! call MPI_Wait(requests(1), status, ierr) ! call rq_check( requests(1), 1, 'isend and irecv' ) ! end if ! end ! subroutine test_pair_irsend( comm, errs ) use mpi integer comm, errs integer rank, size, ierr, next, prev, tag, count, index integer TEST_SIZE integer dupcom parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE), requests(2) integer statuses(MPI_STATUS_SIZE,2) logical flag real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose ! if (verbose) then print *, ' Irsend and irecv' endif ! call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 ! prev = rank - 1 if (prev .lt. 0) prev = size - 1 ! call mpi_comm_dup( comm, dupcom, ierr ) ! tag = 2456 count = TEST_SIZE / 3 ! call clear_test_data(recv_buf,TEST_SIZE) ! if (rank .eq. 0) then ! call MPI_Irecv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & requests(1), ierr) ! call init_test_data(send_buf,TEST_SIZE) ! call MPI_Sendrecv( MPI_BOTTOM, 0, MPI_INTEGER, next, 0, & & MPI_BOTTOM, 0, MPI_INTEGER, next, 0, & & dupcom, status, ierr ) ! call MPI_Irsend(send_buf, count, MPI_REAL, next, tag, & & comm, requests(2), ierr) ! index = -1 do while (index .ne. 1) call MPI_Waitany(2, requests, index, statuses, ierr) end do ! call rq_check( requests(1), 1, 'irsend and irecv' ) ! call msg_check( recv_buf, next, tag, count, statuses, & & TEST_SIZE, 'irsend and irecv', errs ) ! else if (prev .eq. 0) then ! call MPI_Irecv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & requests(1), ierr) ! call MPI_Sendrecv( MPI_BOTTOM, 0, MPI_INTEGER, prev, 0, & & MPI_BOTTOM, 0, MPI_INTEGER, prev, 0, & & dupcom, status, ierr ) ! flag = .FALSE. do while (.not. flag) call MPI_Test(requests(1), flag, status, ierr) end do ! call rq_check( requests, 1, 'irsend and irecv (test)' ) ! call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, & & 'irsend and irecv', errs ) ! call MPI_Irsend(recv_buf, count, MPI_REAL, prev, tag, & & comm, requests(1), ierr) ! call MPI_Waitall(1, requests, statuses, ierr) ! call rq_check( requests, 1, 'irsend and irecv' ) ! end if ! call mpi_comm_free( dupcom, ierr ) ! end ! subroutine test_pair_issend( comm, errs ) use mpi integer comm, errs integer rank, size, ierr, next, prev, tag, count, index integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE), requests(2) integer statuses(MPI_STATUS_SIZE,2) logical flag real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose ! if (verbose) then print *, ' issend and irecv (testall)' endif ! ! call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 ! prev = rank - 1 if (prev .lt. 0) prev = size - 1 ! tag = 2789 count = TEST_SIZE / 3 ! call clear_test_data(recv_buf,TEST_SIZE) ! if (rank .eq. 0) then ! call MPI_Irecv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & requests(1), ierr) ! call init_test_data(send_buf,TEST_SIZE) ! call MPI_Issend(send_buf, count, MPI_REAL, next, tag, & & comm, requests(2), ierr) ! flag = .FALSE. do while (.not. flag) call MPI_Testall(2, requests, flag, statuses, ierr) end do ! call rq_check( requests, 2, 'issend and irecv (testall)' ) ! call msg_check( recv_buf, next, tag, count, statuses(1,1), & & TEST_SIZE, 'issend and recv (testall)', errs ) ! else if (prev .eq. 0) then ! call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & status, ierr) call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, & & 'issend and recv', errs ) call MPI_Issend(recv_buf, count, MPI_REAL, prev, tag, & & comm, requests(1), ierr) ! flag = .FALSE. do while (.not. flag) call MPI_Testany(1, requests(1), index, flag, & & statuses(1,1), ierr) end do ! call rq_check( requests, 1, 'issend and recv (testany)' ) ! end if ! end ! subroutine test_pair_psend( comm, errs ) use mpi integer comm, errs integer rank, size, ierr, next, prev, tag, count, i integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE) integer statuses(MPI_STATUS_SIZE,2), requests(2) real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose ! if (verbose) then print *, ' Persistent send and recv' endif ! call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 ! prev = rank - 1 if (prev .lt. 0) prev = size - 1 ! tag = 3123 count = TEST_SIZE / 5 ! call clear_test_data(recv_buf,TEST_SIZE) call MPI_Recv_init(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & requests(2), ierr) ! if (rank .eq. 0) then ! call init_test_data(send_buf,TEST_SIZE) ! call MPI_Send_init(send_buf, count, MPI_REAL, next, tag, & & comm, requests(1), ierr) ! call MPI_Startall(2, requests, ierr) call MPI_Waitall(2, requests, statuses, ierr) ! call msg_check( recv_buf, next, tag, count, statuses(1,2), & & TEST_SIZE, 'persistent send/recv', errs ) ! call MPI_Request_free(requests(1), ierr) ! else if (prev .eq. 0) then ! call MPI_Send_init(send_buf, count, MPI_REAL, prev, tag, & & comm, requests(1), ierr) call MPI_Start(requests(2), ierr) call MPI_Wait(requests(2), status, ierr) ! call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, & & 'persistent send/recv', errs ) ! do i = 1,count send_buf(i) = recv_buf(i) end do ! call MPI_Start(requests(1), ierr) call MPI_Wait(requests(1), status, ierr) ! call MPI_Request_free(requests(1), ierr) end if ! call dummyRef( send_buf, count, ierr ) call MPI_Request_free(requests(2), ierr) ! end ! subroutine test_pair_prsend( comm, errs ) use mpi integer comm, errs integer rank, size, ierr, next, prev, tag, count, index, i integer outcount, indices(2) integer TEST_SIZE parameter (TEST_SIZE=2000) integer statuses(MPI_STATUS_SIZE,2), requests(2) integer status(MPI_STATUS_SIZE) logical flag real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose ! if (verbose) then print *, ' Persistent Rsend and recv' endif ! call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 ! prev = rank - 1 if (prev .lt. 0) prev = size - 1 ! tag = 3456 count = TEST_SIZE / 3 ! call clear_test_data(recv_buf,TEST_SIZE) ! call MPI_Recv_init(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & requests(2), ierr) ! if (rank .eq. 0) then ! call MPI_Rsend_init(send_buf, count, MPI_REAL, next, tag, & & comm, requests(1), ierr) ! call init_test_data(send_buf,TEST_SIZE) ! call MPI_Recv( MPI_BOTTOM, 0, MPI_INTEGER, next, tag, & & comm, status, ierr ) ! call MPI_Startall(2, requests, ierr) ! index = -1 ! do while (index .ne. 2) call MPI_Waitsome(2, requests, outcount, & & indices, statuses, ierr) do i = 1,outcount if (indices(i) .eq. 2) then call msg_check( recv_buf, next, tag, count, & & statuses(1,i), TEST_SIZE, 'waitsome', errs ) index = 2 end if end do end do ! call MPI_Request_free(requests(1), ierr) else if (prev .eq. 0) then ! call MPI_Rsend_init(send_buf, count, MPI_REAL, prev, tag, & & comm, requests(1), ierr) ! call MPI_Start(requests(2), ierr) ! call MPI_Send( MPI_BOTTOM, 0, MPI_INTEGER, prev, tag, & & comm, ierr ) ! flag = .FALSE. do while (.not. flag) call MPI_Test(requests(2), flag, status, ierr) end do call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, & & 'test', errs ) ! do i = 1,count send_buf(i) = recv_buf(i) end do ! call MPI_Start(requests(1), ierr) call MPI_Wait(requests(1), status, ierr) ! call MPI_Request_free(requests(1), ierr) end if ! call dummyRef( send_buf, count, ierr ) call MPI_Request_free(requests(2), ierr) ! end ! subroutine test_pair_pssend( comm, errs ) use mpi integer comm, errs integer rank, size, ierr, next, prev, tag, count, index, i integer outcount, indices(2) integer TEST_SIZE parameter (TEST_SIZE=2000) integer statuses(MPI_STATUS_SIZE,2), requests(2) integer status(MPI_STATUS_SIZE) logical flag real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose ! if (verbose) then print *, ' Persistent Ssend and recv' endif ! call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 ! prev = rank - 1 if (prev .lt. 0) prev = size - 1 ! tag = 3789 count = TEST_SIZE / 3 ! call clear_test_data(recv_buf,TEST_SIZE) ! call MPI_Recv_init(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & requests(1), ierr) ! if (rank .eq. 0) then ! call MPI_Ssend_init(send_buf, count, MPI_REAL, next, tag, & & comm, requests(2), ierr) ! call init_test_data(send_buf,TEST_SIZE) ! call MPI_Startall(2, requests, ierr) ! index = -1 do while (index .ne. 1) call MPI_Testsome(2, requests, outcount, & & indices, statuses, ierr) do i = 1,outcount if (indices(i) .eq. 1) then call msg_check( recv_buf, next, tag, count, & & statuses(1,i), TEST_SIZE, 'testsome', errs ) index = 1 end if end do end do ! call MPI_Request_free(requests(2), ierr) ! else if (prev .eq. 0) then ! call MPI_Ssend_init(send_buf, count, MPI_REAL, prev, tag, & & comm, requests(2), ierr) ! call MPI_Start(requests(1), ierr) ! flag = .FALSE. do while (.not. flag) call MPI_Testany(1, requests(1), index, flag, & & statuses(1,1), ierr) end do call msg_check( recv_buf, prev, tag, count, statuses(1,1), & & TEST_SIZE, 'testany', errs ) do i = 1,count send_buf(i) = recv_buf(i) end do ! call MPI_Start(requests(2), ierr) call MPI_Wait(requests(2), status, ierr) ! call MPI_Request_free(requests(2), ierr) ! end if ! call dummyRef( send_buf, count, ierr ) call MPI_Request_free(requests(1), ierr) ! end ! subroutine test_pair_sendrecv( comm, errs ) use mpi integer comm, errs integer rank, size, ierr, next, prev, tag, count integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE) real send_buf(TEST_SIZE), recv_buf(TEST_SIZE) logical verbose common /flags/ verbose ! if (verbose) then print *, ' Sendrecv' endif ! ! call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 ! prev = rank - 1 if (prev .lt. 0) prev = size - 1 ! tag = 4123 count = TEST_SIZE / 5 call clear_test_data(recv_buf,TEST_SIZE) if (rank .eq. 0) then call init_test_data(send_buf,TEST_SIZE) call MPI_Sendrecv(send_buf, count, MPI_REAL, next, tag, & & recv_buf, count, MPI_REAL, next, tag, & & comm, status, ierr) call msg_check( recv_buf, next, tag, count, status, TEST_SIZE, & & 'sendrecv', errs ) else if (prev .eq. 0) then call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & status, ierr) call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, & & 'recv/send', errs ) call MPI_Send(recv_buf, count, MPI_REAL, prev, tag, & & comm, ierr) end if ! end ! subroutine test_pair_sendrecvrepl( comm, errs ) use mpi integer comm, errs integer rank, size, ierr, next, prev, tag, count, i integer TEST_SIZE parameter (TEST_SIZE=2000) integer status(MPI_STATUS_SIZE) real recv_buf(TEST_SIZE) logical verbose common /flags/ verbose ! if (verbose) then print *, ' Sendrecv replace' endif ! call mpi_comm_rank( comm, rank, ierr ) call mpi_comm_size( comm, size, ierr ) next = rank + 1 if (next .ge. size) next = 0 ! prev = rank - 1 if (prev .lt. 0) prev = size - 1 ! tag = 4456 count = TEST_SIZE / 3 if (rank .eq. 0) then ! call init_test_data(recv_buf, TEST_SIZE) ! do 11 i = count+1,TEST_SIZE recv_buf(i) = 0.0 11 continue ! call MPI_Sendrecv_replace(recv_buf, count, MPI_REAL, & & next, tag, next, tag, & & comm, status, ierr) call msg_check( recv_buf, next, tag, count, status, TEST_SIZE, & & 'sendrecvreplace', errs ) else if (prev .eq. 0) then call clear_test_data(recv_buf,TEST_SIZE) call MPI_Recv(recv_buf, TEST_SIZE, MPI_REAL, & & MPI_ANY_SOURCE, MPI_ANY_TAG, comm, & & status, ierr) call msg_check( recv_buf, prev, tag, count, status, TEST_SIZE, & & 'recv/send for replace', errs ) call MPI_Send(recv_buf, count, MPI_REAL, prev, tag, & & comm, ierr) end if ! end ! !------------------------------------------------------------------------------ ! ! Check for correct source, tag, count, and data in test message. ! !------------------------------------------------------------------------------ subroutine msg_check( recv_buf, source, tag, count, status, n, & & name, errs ) use mpi integer n, errs real recv_buf(n) integer source, tag, count, rank, status(MPI_STATUS_SIZE) character*(*) name logical foundError integer ierr, recv_src, recv_tag, recv_count foundError = .false. recv_src = status(MPI_SOURCE) recv_tag = status(MPI_TAG) call MPI_Comm_rank( MPI_COMM_WORLD, rank, ierr ) call MPI_Get_count(status, MPI_REAL, recv_count, ierr) if (recv_src .ne. source) then print *, '[', rank, '] Unexpected source:', recv_src, & & ' in ', name errs = errs + 1 foundError = .true. end if if (recv_tag .ne. tag) then print *, '[', rank, '] Unexpected tag:', recv_tag, ' in ', name errs = errs + 1 foundError = .true. end if if (recv_count .ne. count) then print *, '[', rank, '] Unexpected count:', recv_count, & & ' in ', name errs = errs + 1 foundError = .true. end if call verify_test_data(recv_buf, count, n, name, errs ) end !------------------------------------------------------------------------------ ! ! Check that requests have been set to null ! !------------------------------------------------------------------------------ subroutine rq_check( requests, n, msg ) use mpi integer n, requests(n) character*(*) msg integer i ! do 10 i=1, n if (requests(i) .ne. MPI_REQUEST_NULL) then print *, 'Nonnull request in ', msg endif 10 continue ! end !------------------------------------------------------------------------------ ! ! Initialize test data buffer with integral sequence. ! !------------------------------------------------------------------------------ subroutine init_test_data(buf,n) integer n real buf(n) integer i do 10 i = 1, n buf(i) = REAL(i) 10 continue end !------------------------------------------------------------------------------ ! ! Clear test data buffer ! !------------------------------------------------------------------------------ subroutine clear_test_data(buf, n) integer n real buf(n) integer i do 10 i = 1, n buf(i) = 0. 10 continue end !------------------------------------------------------------------------------ ! ! Verify test data buffer ! !------------------------------------------------------------------------------ subroutine verify_test_data( buf, count, n, name, errs ) use mpi integer n, errs real buf(n) character *(*) name integer count, i ! do 10 i = 1, count if (buf(i) .ne. REAL(i)) then print 100, buf(i), i, count, name errs = errs + 1 endif 10 continue ! do 20 i = count + 1, n if (buf(i) .ne. 0.) then print 100, buf(i), i, n, name errs = errs + 1 endif 20 continue ! 100 format('Invalid data', f6.1, ' at ', i4, ' of ', i4, ' in ', a) ! end ! ! This routine is used to prevent the compiler from deallocating the ! array "a", which may happen in some of the tests (see the text in ! the MPI standard about why this may be a problem in valid Fortran ! codes). Without this, for example, tests fail with the Cray ftn ! compiler. ! subroutine dummyRef( a, n, ie ) integer n, ie real a(n) ! This condition will never be true, but the compile won't know that if (ie .eq. -1) then print *, a(n) endif return end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/pt2pt/greqf90.f90000644 001750 001750 00000006765 12342443663 022442 0ustar00cici000000 000000 ! This file created from test/mpi/f77/pt2pt/greqf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! subroutine query_fn( extrastate, status, ierr ) use mpi integer status(MPI_STATUS_SIZE), ierr integer (kind=MPI_ADDRESS_KIND) extrastate ! ! set a default status status(MPI_SOURCE) = MPI_UNDEFINED status(MPI_TAG) = MPI_UNDEFINED call mpi_status_set_cancelled( status, .false., ierr) call mpi_status_set_elements( status, MPI_BYTE, 0, ierr ) ierr = MPI_SUCCESS extrastate = extrastate end ! subroutine free_fn( extrastate, ierr ) use mpi integer ierr integer (kind=MPI_ADDRESS_KIND) extrastate integer freefncall common /fnccalls/ freefncall ! ! For testing purposes, the following print can be used to check whether ! the free_fn is called ! print *, 'Free_fn called' ! extrastate = extrastate - 1 ! The value returned by the free function is the error code ! returned by the wait/test function ierr = MPI_SUCCESS end ! subroutine cancel_fn( extrastate, complete, ierr ) use mpi integer ierr logical complete integer (kind=MPI_ADDRESS_KIND) extrastate ierr = MPI_SUCCESS complete=.true. extrastate=extrastate end ! ! ! This is a very simple test of generalized requests. Normally, the ! MPI_Grequest_complete function would be called from another routine, ! often running in a separate thread. This simple code allows us to ! check that requests can be created, tested, and waited on in the ! case where the request is complete before the wait is called. ! ! Note that MPI did *not* define a routine that can be called within ! test or wait to advance the state of a generalized request. ! Most uses of generalized requests will need to use a separate thread. ! program main use mpi integer errs, ierr logical flag integer status(MPI_STATUS_SIZE) integer request external query_fn, free_fn, cancel_fn integer (kind=MPI_ADDRESS_KIND) extrastate integer freefncall common /fnccalls/ freefncall errs = 0 freefncall = 0 call MTest_Init( ierr ) extrastate = 0 call mpi_grequest_start( query_fn, free_fn, cancel_fn, & & extrastate, request, ierr ) call mpi_test( request, flag, status, ierr ) if (flag) then errs = errs + 1 print *, 'Generalized request marked as complete' endif call mpi_grequest_complete( request, ierr ) call MPI_Wait( request, status, ierr ) extrastate = 1 call mpi_grequest_start( query_fn, free_fn, cancel_fn, & & extrastate, request, ierr ) call mpi_grequest_complete( request, ierr ) call mpi_wait( request, MPI_STATUS_IGNORE, ierr ) ! ! The following routine may prevent an optimizing compiler from ! just remembering that extrastate was set in grequest_start call dummyupdate(extrastate) if (extrastate .ne. 0) then errs = errs + 1 if (freefncall .eq. 0) then print *, 'Free routine not called' else print *, 'Free routine did not update extra_data' print *, 'extrastate = ', extrastate endif endif ! call MTest_Finalize( errs ) call mpi_finalize( ierr ) end ! SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/pt2pt/mprobef90.f90000644 001750 001750 00000057320 12342443663 022761 0ustar00cici000000 000000 ! This file created from test/mpi/f77/pt2pt/mprobef.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2012 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main use mpi integer idx, ierr, rank, size, count integer sendbuf(8), recvbuf(8) integer s1(MPI_STATUS_SIZE), s2(MPI_STATUS_SIZE) integer msg, errs integer rreq logical found, flag ierr = -1 errs = 0 call mpi_init( ierr ) if (ierr .ne. MPI_SUCCESS) then errs = errs + 1 print *, ' Unexpected return from MPI_INIT', ierr endif call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) call mpi_comm_size( MPI_COMM_WORLD, size, ierr ) if (size .lt. 2) then errs = errs + 1 print *, ' This test requires at least 2 processes' ! Abort now - do not continue in this case. call mpi_abort( MPI_COMM_WORLD, 1, ierr ) endif if (size .gt. 2) then print *, ' This test is running with ', size, ' processes,' print *, ' only 2 processes are used.' endif ! Test 0: simple Send and Mprobe+Mrecv. if (rank .eq. 0) then sendbuf(1) = 1735928559 sendbuf(2) = 1277009102 call MPI_Send(sendbuf, 2, MPI_INTEGER, & & 1, 5, MPI_COMM_WORLD, ierr) else do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo ! the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER msg = MPI_MESSAGE_NULL call MPI_Mprobe(0, 5, MPI_COMM_WORLD, msg, s1, ierr) if (s1(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's1(MPI_SOURCE) != 0 at T0 Mprobe().' endif if (s1(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's1(MPI_TAG) != 5 at T0 Mprobe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T0 Mprobe().' endif if (msg .eq. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg == MPI_MESSAGE_NULL at T0 Mprobe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 2) then errs = errs + 1 print *, 'probed buffer does not have 2 MPI_INTEGERs.' endif recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Mrecv(recvbuf, count, MPI_INTEGER, msg, s2, ierr) if (recvbuf(1) .ne. 1735928559) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T0 Mrecv().' endif if (recvbuf(2) .ne. 1277009102) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T0 Mrecv().' endif if (s2(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's2(MPI_SOURCE) != 0 at T0 Mrecv().' endif if (s2(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's2(MPI_TAG) != 5 at T0 Mrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T0 Mrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T0 Mrecv().' endif endif ! Test 1: simple Send and Mprobe+Imrecv. if (rank .eq. 0) then sendbuf(1) = 1735928559 sendbuf(2) = 1277009102 call MPI_Send(sendbuf, 2, MPI_INTEGER, & & 1, 5, MPI_COMM_WORLD, ierr) else do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo ! the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER msg = MPI_MESSAGE_NULL call MPI_Mprobe(0, 5, MPI_COMM_WORLD, msg, s1, ierr) if (s1(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's1(MPI_SOURCE) != 0 at T1 Mprobe().' endif if (s1(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's1(MPI_TAG) != 5 at T1 Mprobe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T1 Mprobe().' endif if (msg .eq. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg == MPI_MESSAGE_NULL at T1 Mprobe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 2) then errs = errs + 1 print *, 'probed buffer does not have 2 MPI_INTEGERs.' endif rreq = MPI_REQUEST_NULL recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Imrecv(recvbuf, count, MPI_INTEGER, msg, rreq, ierr) if (rreq .eq. MPI_REQUEST_NULL) then errs = errs + 1 print *, 'rreq is unmodified at T1 Imrecv().' endif call MPI_Wait(rreq, s2, ierr) if (recvbuf(1) .ne. 1735928559) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T1 Imrecv().' endif if (recvbuf(2) .ne. 1277009102) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T1 Imrecv().' endif if (s2(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's2(MPI_SOURCE) != 0 at T1 Imrecv().' endif if (s2(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's2(MPI_TAG) != 5 at T1 Imrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T1 Imrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T1 Imrecv().' endif endif ! Test 2: simple Send and Improbe+Mrecv. if (rank .eq. 0) then sendbuf(1) = 1735928559 sendbuf(2) = 1277009102 call MPI_Send(sendbuf, 2, MPI_INTEGER, & & 1, 5, MPI_COMM_WORLD, ierr) else do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo ! the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER msg = MPI_MESSAGE_NULL call MPI_Improbe(0, 5, MPI_COMM_WORLD, found, msg, s1, ierr) do while (.not. found) call MPI_Improbe(0, 5, MPI_COMM_WORLD, & & found, msg, s1, ierr) enddo if (msg .eq. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg == MPI_MESSAGE_NULL at T2 Improbe().' endif if (s1(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's1(MPI_SOURCE) != 0 at T2 Improbe().' endif if (s1(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's1(MPI_TAG) != 5 at T2 Improbe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T2 Improbe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 2) then errs = errs + 1 print *, 'probed buffer does not have 2 MPI_INTEGERs.' endif recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Mrecv(recvbuf, count, MPI_INTEGER, msg, s2, ierr) if (recvbuf(1) .ne. 1735928559) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T2 Mrecv().' endif if (recvbuf(2) .ne. 1277009102) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T2 Mrecv().' endif if (s2(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's2(MPI_SOURCE) != 0 at T2 Mrecv().' endif if (s2(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's2(MPI_TAG) != 5 at T2 Mrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T2 Mrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T2 Mrecv().' endif endif ! Test 3: simple Send and Improbe+Imrecv. if (rank .eq. 0) then sendbuf(1) = 1735928559 sendbuf(2) = 1277009102 call MPI_Send(sendbuf, 2, MPI_INTEGER, & & 1, 5, MPI_COMM_WORLD, ierr) else do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo ! the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER msg = MPI_MESSAGE_NULL call MPI_Improbe(0, 5, MPI_COMM_WORLD, found, msg, s1, ierr) do while (.not. found) call MPI_Improbe(0, 5, MPI_COMM_WORLD, & & found, msg, s1, ierr) enddo if (msg .eq. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg == MPI_MESSAGE_NULL at T3 Improbe().' endif if (s1(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's1(MPI_SOURCE) != 0 at T3 Improbe().' endif if (s1(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's1(MPI_TAG) != 5 at T3 Improbe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T3 Improbe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 2) then errs = errs + 1 print *, 'probed buffer does not have 2 MPI_INTEGERs.' endif rreq = MPI_REQUEST_NULL recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Imrecv(recvbuf, count, MPI_INTEGER, msg, rreq, ierr) if (rreq .eq. MPI_REQUEST_NULL) then errs = errs + 1 print *, 'rreq is unmodified at T3 Imrecv().' endif call MPI_Wait(rreq, s2, ierr) if (recvbuf(1) .ne. 1735928559) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T3 Imrecv().' endif if (recvbuf(2) .ne. 1277009102) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T3 Imrecv().' endif if (s2(MPI_SOURCE) .ne. 0) then errs = errs + 1 print *, 's2(MPI_SOURCE) != 0 at T3 Imrecv().' endif if (s2(MPI_TAG) .ne. 5) then errs = errs + 1 print *, 's2(MPI_TAG) != 5 at T3 Imrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T3 Imrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T3 Imrecv().' endif endif ! Test 4: Mprobe+Mrecv with MPI_PROC_NULL if (.true.) then do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo ! the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER msg = MPI_MESSAGE_NULL call MPI_Mprobe(MPI_PROC_NULL, 5, MPI_COMM_WORLD, & & msg, s1, ierr) if (s1(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's1(MPI_SOURCE) != MPI_PROC_NULL at T4 Mprobe().' endif if (s1(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's1(MPI_TAG) != MPI_ANY_TAG at T4 Mprobe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T4 Mprobe().' endif if (msg .ne. MPI_MESSAGE_NO_PROC) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NO_PROC at T4 Mprobe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'probed buffer does not have 0 MPI_INTEGER.' endif recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Mrecv(recvbuf, count, MPI_INTEGER, msg, s2, ierr) ! recvbuf() should remain unmodified if (recvbuf(1) .ne. 19088743) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T4 Mrecv().' endif if (recvbuf(2) .ne. 1309737967) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T4 Mrecv().' endif if (s2(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's2(MPI_SOURCE) != MPI_PROC_NULL at T4 Mrecv().' endif if (s2(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's2(MPI_TAG) != MPI_ANY_TAG at T4 Mrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T4 Mrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T4 Mrecv().' endif count = -1 call MPI_Get_count(s2, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'recv buffer does not have 0 MPI_INTEGER.' endif endif ! Test 5: Mprobe+Imrecv with MPI_PROC_NULL if (.true.) then do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo ! the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER msg = MPI_MESSAGE_NULL call MPI_Mprobe(MPI_PROC_NULL, 5, MPI_COMM_WORLD, & & msg, s1, ierr) if (s1(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's1(MPI_SOURCE) != MPI_PROC_NULL at T5 Mprobe().' endif if (s1(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's1(MPI_TAG) != MPI_ANY_TAG at T5 Mprobe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T5 Mprobe().' endif if (msg .ne. MPI_MESSAGE_NO_PROC) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NO_PROC at T5 Mprobe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'probed buffer does not have 0 MPI_INTEGER.' endif rreq = MPI_REQUEST_NULL recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Imrecv(recvbuf, count, MPI_INTEGER, msg, rreq, ierr) if (rreq .eq. MPI_REQUEST_NULL) then errs = errs + 1 print *, 'rreq == MPI_REQUEST_NULL at T5 Imrecv().' endif flag = .false. call MPI_Test(rreq, flag, s2, ierr) if (.not. flag) then errs = errs + 1 print *, 'flag is false at T5 Imrecv().' endif ! recvbuf() should remain unmodified if (recvbuf(1) .ne. 19088743) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T5 Imrecv().' endif if (recvbuf(2) .ne. 1309737967) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T5 Imrecv().' endif if (s2(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's2(MPI_SOURCE) != MPI_PROC_NULL at T5 Imrecv().' endif if (s2(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's2(MPI_TAG) != MPI_ANY_TAG at T5 Imrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T5 Imrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T5 Imrecv().' endif count = -1 call MPI_Get_count(s2, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'recv buffer does not have 0 MPI_INTEGER.' endif endif ! Test 6: Improbe+Mrecv with MPI_PROC_NULL if (.true.) then do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo ! the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER found = .false. msg = MPI_MESSAGE_NULL call MPI_Improbe(MPI_PROC_NULL, 5, MPI_COMM_WORLD, & & found, msg, s1, ierr) if (.not. found) then errs = errs + 1 print *, 'found is false at T6 Improbe().' endif if (s1(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's1(MPI_SOURCE) != MPI_PROC_NULL at T6 Improbe()' endif if (s1(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's1(MPI_TAG) != MPI_ANY_TAG at T6 Improbe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T6 Improbe().' endif if (msg .ne. MPI_MESSAGE_NO_PROC) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NO_PROC at T6 Improbe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'probed buffer does not have 0 MPI_INTEGER.' endif recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Mrecv(recvbuf, count, MPI_INTEGER, msg, s2, ierr) ! recvbuf() should remain unmodified if (recvbuf(1) .ne. 19088743) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T6 Mrecv().' endif if (recvbuf(2) .ne. 1309737967) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T6 Mrecv().' endif if (s2(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's2(MPI_SOURCE) != MPI_PROC_NULL at T6 Mrecv().' endif if (s2(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's2(MPI_TAG) != MPI_ANY_TAG at T6 Mrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T6 Mrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T6 Mrecv().' endif count = -1 call MPI_Get_count(s2, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'recv buffer does not have 0 MPI_INTEGER.' endif endif ! Test 7: Improbe+Imrecv with MPI_PROC_NULL if (.true.) then do idx = 1, MPI_STATUS_SIZE s1(idx) = 0 s2(idx) = 0 enddo ! the error fields are initialized for modification check. s1(MPI_ERROR) = MPI_ERR_DIMS s2(MPI_ERROR) = MPI_ERR_OTHER found = .false. msg = MPI_MESSAGE_NULL call MPI_Improbe(MPI_PROC_NULL, 5, MPI_COMM_WORLD, & & found, msg, s1, ierr) if (.not. found) then errs = errs + 1 print *, 'found is false at T7 Improbe().' endif if (s1(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's1(MPI_SOURCE) != MPI_PROC_NULL at T7 Improbe()' endif if (s1(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's1(MPI_TAG) != MPI_ANY_TAG at T7 Improbe().' endif if (s1(MPI_ERROR) .ne. MPI_ERR_DIMS) then errs = errs + 1 print *, 's1(MPI_ERROR) != MPI_ERR_DIMS at T7 Improbe().' endif if (msg .ne. MPI_MESSAGE_NO_PROC) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NO_PROC at T7 Improbe().' endif count = -1 call MPI_Get_count(s1, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'probed buffer does not have 0 MPI_INTEGER.' endif rreq = MPI_REQUEST_NULL recvbuf(1) = 19088743 recvbuf(2) = 1309737967 call MPI_Imrecv(recvbuf, count, MPI_INTEGER, msg, rreq, ierr) if (rreq .eq. MPI_REQUEST_NULL) then errs = errs + 1 print *, 'rreq == MPI_REQUEST_NULL at T7 Imrecv().' endif flag = .false. call MPI_Test(rreq, flag, s2, ierr) if (.not. flag) then errs = errs + 1 print *, 'flag is false at T7 Imrecv().' endif ! recvbuf() should remain unmodified if (recvbuf(1) .ne. 19088743) then errs = errs + 1 print *, 'recvbuf(1) is corrupted at T7 Imrecv().' endif if (recvbuf(2) .ne. 1309737967) then errs = errs + 1 print *, 'recvbuf(2) is corrupted at T7 Imrecv().' endif if (s2(MPI_SOURCE) .ne. MPI_PROC_NULL) then errs = errs + 1 print *, 's2(MPI_SOURCE) != MPI_PROC_NULL at T7 Imrecv().' endif if (s2(MPI_TAG) .ne. MPI_ANY_TAG) then errs = errs + 1 print *, 's2(MPI_TAG) != MPI_ANY_TAG at T7 Imrecv().' endif if (s2(MPI_ERROR) .ne. MPI_ERR_OTHER) then errs = errs + 1 print *, 's2(MPI_ERROR) != MPI_ERR_OTHER at T7 Imrecv().' endif if (msg .ne. MPI_MESSAGE_NULL) then errs = errs + 1 print *, 'msg != MPI_MESSAGE_NULL at T7 Imrecv().' endif count = -1 call MPI_Get_count(s2, MPI_INTEGER, count, ierr) if (count .ne. 0) then errs = errs + 1 print *, 'recv buffer does not have 0 MPI_INTEGER.' endif endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/pt2pt/statusesf90.f90000644 001750 001750 00000003241 12342443663 023341 0ustar00cici000000 000000 ! This file created from test/mpi/f77/pt2pt/statusesf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2003 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! program main ! Test support for MPI_STATUS_IGNORE and MPI_STATUSES_IGNORE use mpi integer nreqs parameter (nreqs = 100) integer reqs(nreqs) integer ierr, rank, i integer errs ierr = -1 errs = 0 call mpi_init( ierr ) if (ierr .ne. MPI_SUCCESS) then errs = errs + 1 print *, 'Unexpected return from MPI_INIT', ierr endif ierr = -1 call mpi_comm_rank( MPI_COMM_WORLD, rank, ierr ) if (ierr .ne. MPI_SUCCESS) then errs = errs + 1 print *, 'Unexpected return from MPI_COMM_WORLD', ierr endif do i=1, nreqs, 2 ierr = -1 call mpi_isend( MPI_BOTTOM, 0, MPI_BYTE, rank, i, & & MPI_COMM_WORLD, reqs(i), ierr ) if (ierr .ne. MPI_SUCCESS) then errs = errs + 1 print *, 'Unexpected return from MPI_ISEND', ierr endif ierr = -1 call mpi_irecv( MPI_BOTTOM, 0, MPI_BYTE, rank, i, & & MPI_COMM_WORLD, reqs(i+1), ierr ) if (ierr .ne. MPI_SUCCESS) then errs = errs + 1 print *, 'Unexpected return from MPI_IRECV', ierr endif enddo ierr = -1 call mpi_waitall( nreqs, reqs, MPI_STATUSES_IGNORE, ierr ) if (ierr .ne. MPI_SUCCESS) then errs = errs + 1 print *, 'Unexpected return from MPI_WAITALL', ierr endif call mtest_finalize( errs ) call mpi_finalize( ierr ) end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/pt2pt/dummyf90.f90000644 001750 001750 00000001460 12342443663 022622 0ustar00cici000000 000000 ! This file created from test/mpi/f77/pt2pt/dummyf.f with f77tof90 ! -*- Mode: Fortran; -*- ! ! (C) 2010 by Argonne National Laboratory. ! See COPYRIGHT in top-level directory. ! ! ! This file is used to disable certain compiler optimizations that ! can cause incorrect results with the test in greqf.f. It provides a ! point where extrastate may be modified, limiting the compilers ability ! to move code around. ! The include of mpif.h is not needed in the F77 case but in the ! F90 case it is, because in that case, extrastate is defined as an ! integer (kind=MPI_ADDRESS_KIND), and the script that creates the ! F90 tests from the F77 tests looks for mpif.h subroutine dummyupdate( extrastate ) use mpi integer (kind=MPI_ADDRESS_KIND) extrastate extrastate=extrastate end SimGrid-3.11/teshsuite/smpi/mpich3-test/f90/pt2pt/CMakeLists.txt000644 001750 001750 00000002573 12342443654 023376 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite AND SMPI_F90) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpif90") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(allpairf90 allpairf90.f90) # add_executable(greqf90 greqf90.f90 dummyf90.f90) # add_executable(mprobef90 mprobef90.f90) add_executable(statusesf90 statusesf90.f90) target_link_libraries(allpairf90 simgrid mtest_f90) # target_link_libraries(greqf90 simgrid mtest_f90) # target_link_libraries(mprobef90 simgrid mtest_f90) target_link_libraries(statusesf90 simgrid mtest_f90) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/allpairf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/dummyf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/greqf90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/mprobef90.f90 ${CMAKE_CURRENT_SOURCE_DIR}/statusesf90.f90 PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/runtests000755 001750 001750 00000103205 12342443666 021001 0ustar00cici000000 000000 #! /usr/bin/perl # -*- Mode: perl; -*- # # This script is the beginnings of a script to run a sequence of test # programs. See the MPICH document for a description of the test # strategy and requirements. # # Description # Tests are controlled by a file listing test programs; if the file is # a directory, then all of the programs in the directory and subdirectories # are run # # To run a test, the following steps are executed # Build the executable: # make programname # Run the executable # mpiexec -n ./programname >out 2>err # Check the return code (non zero is failure) # Check the stderr output (non empty is failure) # Check the stdout output (No Errors or Test passed are the only valid # output) # Remove executable, out, err files # # The format of a list file is # programname number-of-processes # If number-of-processes is missing, $np_default is used (this is 2 but can # be overridden with -np=new-value) # # Special feature: # Because these tests can take a long time to run, there is an # option to cause the tests to stop is a "stopfile" is found. # The stopfile can be created by a separate, watchdog process, to ensure that # tests end at a certain time. # The name of this file is (by default) .stoptest # in the top-level run directory. The environment variable # MPITEST_STOPTEST # can specify a different file name. # # Import the mkpath command use File::Path; # Global variables $MPIMajorVersion = "1"; $MPIMinorVersion = "1"; $mpiexec = "smpirun"; # Name of mpiexec program (including path, if necessary) $testIsStrict = "true"; $MPIhasMPIX = "no"; $np_arg = "-np"; # Name of argument to specify the number of processes $err_count = 0; # Number of programs that failed. $total_run = 0; # Number of programs tested $total_seen = 0; # Number of programs considered for testing $np_default = 2; # Default number of processes to use $np_max = -1; # Maximum number of processes to use (overrides any # value in the test list files. -1 is Infinity $defaultTimeLimit = 180; # default timeout $srcdir = "."; # Used to set the source dir for testlist files $curdir = "."; # used to track the relative current directory # Output forms $xmloutput = 0; # Set to true to get xml output (also specify file) $closeXMLOutput = 1; # Set to false to leave XML output file open to # accept additional data $verbose = 1; # Set to true to get more output $showProgress = 0; # Set to true to get a "." with each run program. $newline = "\r\n"; # Set to \r\n for Windows-friendly, \n for Unix only $batchRun = 0; # Set to true to batch the execution of the tests # (i.e., run them together, then test output, # rather than build/run/check for each test) $testCount = 0; # Used with batchRun to count tests. $batrundir = "."; # Set to the directory into which to run the examples $execarg=""; # TAP (Test Anything Protocol) output my $tapoutput = 0; my $tapfile = ''; my $tapfullfile = ''; $debug = 1; $depth = 0; # This is used to manage multiple open list files # Build flags $remove_this_pgm = 0; $clean_pgms = 0; my $program_wrapper = ''; #--------------------------------------------------------------------------- # Get some arguments from the environment # Currently, only the following are understood: # VERBOSE # RUNTESTS_VERBOSE (an alias for VERBOSE in case you want to # reserve VERBOSE) # RUNTESTS_SHOWPROGRESS # MPITEST_STOPTEST # MPITEST_TIMEOUT # MPITEST_PROGRAM_WRAPPER (Value is added after -np but before test # executable. Tools like valgrind may be inserted # this way.) #--------------------------------------------------------------------------- if ( defined($ENV{"VERBOSE"}) || defined($ENV{"V"}) || defined($ENV{"RUNTESTS_VERBOSE"}) ) { $verbose = 1; } if ( defined($ENV{"RUNTESTS_SHOWPROGRESS"} ) ) { $showProgress = 1; } if (defined($ENV{"MPITEST_STOPTEST"})) { $stopfile = $ENV{"MPITEST_STOPTEST"}; } else { $stopfile = `pwd` . "/.stoptest"; $stopfile =~ s/\r*\n*//g; # Remove any newlines (from pwd) } if (defined($ENV{"MPITEST_TIMEOUT"})) { $defaultTimeLimit = $ENV{"MPITEST_TIMEOUT"}; } # Define this to leave the XML output file open to receive additional data if (defined($ENV{'NOXMLCLOSE'}) && $ENV{'NOXMLCLOSE'} eq 'YES') { $closeXMLOutput = 0; } if (defined($ENV{'MPITEST_PROGRAM_WRAPPER'})) { $program_wrapper = $ENV{'MPITEST_PROGRAM_WRAPPER'}; } if (defined($ENV{'MPITEST_BATCH'})) { if ($ENV{'MPITEST_BATCH'} eq 'YES' || $ENV{'MPITEST_BATCH'} eq 'yes') { $batchRun = 1; } elsif ($ENV{'MPITEST_BATCH'} eq 'NO' || $ENV{'MPITEST_BATCH'} eq 'no') { $batchRun = 0; } else { print STDERR "Unrecognized value for MPITEST_BATCH = $ENV{'MPITEST_BATCH'}\n"; } } if (defined($ENV{'MPITEST_BATCHDIR'})) { $batrundir = $ENV{'MPITEST_BATCHDIR'}; } #--------------------------------------------------------------------------- # Process arguments and override any defaults #--------------------------------------------------------------------------- foreach $_ (@ARGV) { if (/--?mpiexec=(.*)/) { # Use mpiexec as given - it may be in the path, and # we don't want to bother to try and find it. $mpiexec = $1; } elsif (/--?np=(.*)/) { $np_default = $1; } elsif (/--?maxnp=(.*)/) { $np_max = $1; } elsif (/--?tests=(.*)/) { $listfiles = $1; } elsif (/--?srcdir=(.*)/) { $srcdir = $1; $mpiexec="$mpiexec -platform ${srcdir}/../../../../examples/msg/small_platform_with_routers.xml -hostfile ${srcdir}/../hostfile --log=root.thr:critical --cfg=smpi/running_power:1e9"; } elsif (/--?verbose/) { $verbose = 1; } elsif (/--?showprogress/) { $showProgress = 1; } elsif (/--?debug/) { $debug = 1; } elsif (/--?batch/) { $batchRun = 1; } elsif (/--?batchdir=(.*)/) { $batrundir = $1; } elsif (/--?timeoutarg=(.*)/) { $timeoutArgPattern = $1; } elsif (/--?execarg=(.*)/) { $execarg = "$execarg $1"; } elsif (/--?xmlfile=(.*)/) { $xmlfile = $1; if (! ($xmlfile =~ /^\//)) { $thisdir = `pwd`; chop $thisdir; $xmlfullfile = $thisdir . "/" . $xmlfile ; } else { $xmlfullfile = $xmlfile; } $xmloutput = 1; open( XMLOUT, ">$xmlfile" ) || die "Cannot open $xmlfile\n"; my $date = `date "+%Y-%m-%d-%H-%M"`; $date =~ s/\r?\n//; # MPISOURCE can be used to describe the source of MPI for this # test. print XMLOUT "$newline"; print XMLOUT "$newline"; print XMLOUT "$newline"; print XMLOUT "$date$newline"; print XMLOUT "$newline"; } elsif (/--?noxmlclose/) { $closeXMLOutput = 0; } elsif (/--?tapfile=(.*)/) { $tapfile = $1; if ($tapfile !~ m|^/|) { $thisdir = `pwd`; chomp $thisdir; $tapfullfile = $thisdir . "/" . $tapfile ; } else { $tapfullfile = $tapfile; } $tapoutput = 1; open( TAPOUT, ">$tapfile" ) || die "Cannot open $tapfile\n"; my $date = `date "+%Y-%m-%d-%H-%M"`; $date =~ s/\r?\n//; print TAPOUT "TAP version 13\n"; print TAPOUT "# MPICH test suite results (TAP format)\n"; print TAPOUT "# date ${date}\n"; # we do not know at this point how many tests will be run, so do # not print a test plan line like "1..450" until the very end } else { print STDERR "Unrecognized argument $_\n"; print STDERR "runtests [-tests=testfile] [-np=nprocesses] \ [-maxnp=max-nprocesses] [-srcdir=location-of-tests] \ [-xmlfile=filename ] [-noxmlclose] \ [-verbose] [-showprogress] [-debug] [-batch]\n"; exit(1); } } # Perform any post argument processing if ($batchRun) { if (! -d $batrundir) { mkpath $batrundir || die "Could not create $batrundir\n"; } open( BATOUT, ">$batrundir/runtests.batch" ) || die "Could not open $batrundir/runtests.batch\n"; } else { # We must have mpiexec if ("$mpiexec" eq "") { print STDERR "No mpiexec found!\n"; exit(1); } } # # Process any files if ($listfiles eq "") { if ($batchRun) { print STDERR "An implicit list of tests is not permitted in batch mode\n"; exit(1); } else { &ProcessImplicitList; } } elsif (-d $listfiles) { print STDERR "Testing by directories not yet supported\n"; } else { &RunList( $listfiles ); } if ($xmloutput && $closeXMLOutput) { print XMLOUT "$newline"; close XMLOUT; } if ($tapoutput) { print TAPOUT "1..$total_seen\n"; close TAPOUT; } # Output a summary: if ($batchRun) { print "Programs created along with a runtest.batch file in $batrundir\n"; print "Run that script and then use checktests to summarize the results\n"; } else { if ($err_count) { print "$err_count tests failed out of $total_run\n"; if ($xmloutput) { print "Details in $xmlfullfile\n"; } } else { print " All $total_run tests passed!\n"; } if ($tapoutput) { print "TAP formatted results in $tapfullfile\n"; } } # # --------------------------------------------------------------------------- # Routines # # Enter a new directory and process a list file. # ProcessDir( directory-name, list-file-name ) sub ProcessDir { my $dir = $_[0]; $dir =~ s/\/$//; my $listfile = $_[1]; my $savedir = `pwd`; my $savecurdir = $curdir; my $savesrcdir = $srcdir; chop $savedir; if (substr($srcdir,0,3) eq "../") { $srcdir = "../$srcdir"; } print "Processing directory $dir\n" if ($verbose || $debug); chdir $dir; if ($dir =~ /\//) { print STDERR "only direct subdirectories allowed in list files"; } $curdir .= "/$dir"; &RunList( $listfile ); print "\n" if $showProgress; # Terminate line from progress output chdir $savedir; $curdir = $savecurdir; $srcdir = $savesrcdir; } # --------------------------------------------------------------------------- # Run the programs listed in the file given as the argument. # This file describes the tests in the format # programname number-of-processes [ key=value ... ] # If the second value is not given, the default value is used. # sub RunList { my $LIST = "LIST$depth"; $depth++; my $listfile = $_[0]; my $ResultTest = ""; my $InitForRun = ""; my $listfileSource = $listfile; print "Looking in $curdir/$listfile\n" if $debug; if (! -s "$listfile" && -s "$srcdir/$curdir/$listfile" ) { $listfileSource = "$srcdir/$curdir/$listfile"; } open( $LIST, "<$listfileSource" ) || die "Could not open $listfileSource\n"; while (<$LIST>) { # Check for stop file if (-s $stopfile) { # Exit because we found a stopfile print STDERR "Terminating test because stopfile $stopfile found\n"; last; } # Skip comments s/#.*//g; # Remove any trailing newlines/returns s/\r?\n//; # Remove any leading whitespace s/^\s*//; # Some tests require that support routines are built first # This is specified with !: if (/^\s*\!([^:]*):(.*)/) { # Hack: just execute in a subshell. This discards any # output. `cd $1 && make $2`; next; } # List file entries have the form: # program [ np [ name=value ... ] ] # See files errhan/testlist, init/testlist, and spawn/testlist # for examples of using the key=value form my @args = split(/\s+/,$_); my $programname = $args[0]; my $np = ""; my $ResultTest = ""; my $InitForRun = ""; my $timeLimit = ""; my $progArgs = ""; my $mpiexecArgs = "$execarg"; my $requiresStrict = ""; my $requiresMPIX = ""; my $progEnv = ""; my $mpiVersion = ""; my $xfail = ""; if ($#args >= 1) { $np = $args[1]; } # Process the key=value arguments for (my $i=2; $i <= $#args; $i++) { if ($args[$i] =~ /([^=]+)=(.*)/) { my $key = $1; my $value = $2; if ($key eq "resultTest") { $ResultTest = $value; } elsif ($key eq "init") { $InitForRun = $value; } elsif ($key eq "timeLimit") { $timeLimit = $value; } elsif ($key eq "arg") { $progArgs = "$progArgs $value"; } elsif ($key eq "mpiexecarg") { $mpiexecArgs = "$mpiexecArgs $value"; } elsif ($key eq "env") { $progEnv = "$progEnv $value"; } elsif ($key eq "mpiversion") { $mpiVersion = $value; } elsif ($key eq "strict") { $requiresStrict = $value } elsif ($key eq "mpix") { $requiresMPIX = $value } elsif ($key eq "xfail") { if ($value eq "") { print STDERR "\"xfail=\" requires an argument\n"; } $xfail = $value; } else { print STDERR "Unrecognized key $key in $listfileSource\n"; } } } # skip empty lines if ($programname eq "") { next; } if ($np eq "") { $np = $np_default; } if ($np_max > 0 && $np > $np_max) { $np = $np_max; } # allows us to accurately output TAP test numbers without disturbing the # original totals that have traditionally been reported # # These "unless" blocks are ugly, but permit us to honor skipping # criteria for directories as well without counting directories as tests # in our XML/TAP output. unless (-d $programname) { $total_seen++; } # If a minimum MPI version is specified, check against the # available MPI. If the version is unknown, we ignore this # test (thus, all tests will be run). if ($mpiVersion ne "" && $MPIMajorVersion ne "unknown" && $MPIMinorVersion ne "unknown") { my ($majorReq,$minorReq) = split(/\./,$mpiVersion); if ($majorReq > $MPIMajorVersion or ($majorReq == $MPIMajorVersion && $minorReq > $MPIMinorVersion)) { unless (-d $programname) { SkippedTest($programname, $np, $workdir, "requires MPI version $mpiVersion"); } next; } } # Check whether strict is required by MPI but not by the # test (use strict=false for tests that use non-standard extensions) if (lc($requiresStrict) eq "false" && lc($testIsStrict) eq "true") { unless (-d $programname) { SkippedTest($programname, $np, $workdir, "non-strict test, strict MPI mode requested"); } next; } if (lc($testIsStrict) eq "true") { # Strict MPI testing was requested, so assume that a non-MPICH MPI # implementation is being tested and the "xfail" implementation # assumptions do not hold. $xfail = ''; } if (lc($requiresMPIX) eq "true" && lc($MPIHasMPIX) eq "no") { unless (-d $programname) { SkippedTest($programname, $np, $workdir, "tests MPIX extensions, MPIX testing disabled"); } next; } if (-d $programname) { # If a directory, go into the that directory and # look for a new list file &ProcessDir( $programname, $listfile ); } else { $total_run++; if (&BuildMPIProgram( $programname, $xfail ) == 0) { if ($batchRun == 1) { &AddMPIProgram( $programname, $np, $ResultTest, $InitForRun, $timeLimit, $progArgs, $progEnv, $mpiexecArgs, $xfail ); } else { &RunMPIProgram( $programname, $np, $ResultTest, $InitForRun, $timeLimit, $progArgs, $progEnv, $mpiexecArgs, $xfail ); } } elsif ($xfail ne '') { # We expected to run this program, so failure to build # is an error $found_error = 1; $err_count++; } if ($batchRun == 0) { &CleanUpAfterRun( $programname ); } } } close( $LIST ); } # # This routine tries to run all of the files in the current # directory sub ProcessImplicitList { # The default is to run every file in the current directory. # If there are no built programs, build and run every file # WARNING: This assumes that anything executable should be run as # an MPI test. $found_exec = 0; $found_src = 0; open (PGMS, "ls -1 |" ) || die "Cannot list directory\n"; while () { s/\r?\n//; $programname = $_; if (-d $programname) { next; } # Ignore directories if ($programname eq "runtests") { next; } # Ignore self if ($programname eq "checktests") { next; } # Ignore helper if ($programname eq "configure") { next; } # Ignore configure script if ($programname eq "config.status") { next; } # Ignore configure helper if (-x $programname) { $found_exec++; } if ($programname =~ /\.[cf]$/) { $found_src++; } } close PGMS; if ($found_exec) { print "Found executables\n" if $debug; open (PGMS, "ls -1 |" ) || die "Cannot list programs\n"; while () { # Check for stop file if (-s $stopfile) { # Exit because we found a stopfile print STDERR "Terminating test because stopfile $stopfile found\n"; last; } s/\r?\n//; $programname = $_; if (-d $programname) { next; } # Ignore directories if ($programname eq "runtests") { next; } # Ignore self if (-x $programname) { $total_run++; &RunMPIProgram( $programname, $np_default, "", "", "", "", "", "", "" ); } } close PGMS; } elsif ($found_src) { print "Found source files\n" if $debug; open (PGMS, "ls -1 *.c |" ) || die "Cannot list programs\n"; while () { if (-s $stopfile) { # Exit because we found a stopfile print STDERR "Terminating test because stopfile $stopfile found\n"; last; } s/\r?\n//; $programname = $_; # Skip messages from ls about no files if (! -s $programname) { next; } $programname =~ s/\.c//; $total_run++; if (&BuildMPIProgram( $programname, "") == 0) { &RunMPIProgram( $programname, $np_default, "", "", "", "", "", "", "" ); } else { # We expected to run this program, so failure to build # is an error $found_error = 1; $err_count++; } &CleanUpAfterRun( $programname ); } close PGMS; } } # Run the program. # ToDo: Add a way to limit the time that any particular program may run. # The arguments are # name of program, number of processes, name of routine to check results # init for testing, timelimit, and any additional program arguments # If the 3rd arg is not present, the a default that simply checks that the # return status is 0 and that the output is " No Errors" is used. sub RunMPIProgram { my ($programname,$np,$ResultTest,$InitForTest,$timeLimit,$progArgs,$progEnv,$mpiexecArgs,$xfail) = @_; my $found_error = 0; my $found_noerror = 0; my $inline = ""; &RunPreMsg( $programname, $np, $curdir ); unlink "err"; # Set a default timeout on tests (3 minutes for now) my $timeout = $defaultTimeLimit; if (defined($timeLimit) && $timeLimit =~ /^\d+$/) { $timeout = $timeLimit; } $ENV{"MPIEXEC_TIMEOUT"} = $timeout; # Run the optional setup routine. For example, the timeout tests could # be set to a shorter timeout. if ($InitForTest ne "") { &$InitForTest(); } print STDOUT "Env includes $progEnv\n" if $verbose; print STDOUT "$mpiexec $mpiexecArgs $np_arg $np $program_wrapper ./$programname $progArgs\n" if $verbose; print STDOUT "." if $showProgress; # Save and restore the environment if necessary before running mpiexec. if ($progEnv ne "") { %saveEnv = %ENV; foreach $val (split(/\s+/, $progEnv)) { if ($val =~ /([^=]+)=(.*)/) { $ENV{$1} = $2; } else { print STDERR "Environment variable/value $val not in a=b form\n"; } } } open ( MPIOUT, "$mpiexec $np_arg $np $mpiexecArgs $program_wrapper ./$programname $progArgs 2>&1 |" ) || die "Could not run ./$programname\n"; if ($progEnv ne "") { %ENV = %saveEnv; } if ($ResultTest ne "") { # Read and process the output ($found_error, $inline) = &$ResultTest( MPIOUT, $programname ); } else { if ($verbose) { $inline = "$mpiexec $np_arg $np $program_wrapper ./$programname\n"; } else { $inline = ""; } while () { print STDOUT $_ if $verbose; # Skip FORTRAN STOP if (/FORTRAN STOP/) { next; } $inline .= $_; if (/^\s*No [Ee]rrors\s*$/ && $found_noerror == 0) { $found_noerror = 1; } if (! /^\s*No [Ee]rrors\s*$/ && !/^\s*Test Passed\s*$/) { print STDERR "Unexpected output in $programname: $_"; if (!$found_error) { $found_error = 1; $err_count ++; } } } if ($found_noerror == 0) { print STDERR "Program $programname exited without No Errors\n"; if (!$found_error) { $found_error = 1; $err_count ++; } } $rc = close ( MPIOUT ); if ($rc == 0) { # Only generate a message if we think that the program # passed the test. if (!$found_error) { $run_status = $?; $signal_num = $run_status & 127; if ($run_status > 255) { $run_status >>= 8; } print STDERR "Program $programname exited with non-zero status $run_status\n"; if ($signal_num != 0) { print STDERR "Program $programname exited with signal $signal_num\n"; } $found_error = 1; $err_count ++; } } } if ($found_error) { &RunTestFailed( $programname, $np, $curdir, $inline, $xfail ); } else { &RunTestPassed( $programname, $np, $curdir, $xfail ); } &RunPostMsg( $programname, $np, $curdir ); } # This version simply writes the mpiexec command out, with the output going # into a file, and recording the output status of the run. sub AddMPIProgram { my ($programname,$np,$ResultTest,$InitForTest,$timeLimit,$progArgs,$progEnv,$mpiexecArgs, $xfail) = @_; if (! -x $programname) { print STDERR "Could not find $programname!"; return; } if ($ResultTest ne "") { # This test really needs to be run manually, with this test # Eventually, we can update this to include handleing in checktests. print STDERR "Run $curdir/$programname with $np processes and use $ResultTest to check the results\n"; return; } # Set a default timeout on tests (3 minutes for now) my $timeout = $defaultTimeLimit; if (defined($timeLimit) && $timeLimit =~ /^\d+$/) { # On some systems, there is no effective time limit on # individual mpi program runs. In that case, we may # want to treat these also as "run manually". $timeout = $timeLimit; } print BATOUT "export MPIEXEC_TIMEOUT=$timeout\n"; # Run the optional setup routine. For example, the timeout tests could # be set to a shorter timeout. if ($InitForTest ne "") { &$InitForTest(); } # For non-MPICH versions of mpiexec, a timeout may require a different # environment variable or command line option (e.g., for Cray aprun, # the option -t must be given, there is no environment variable # to set the timeout. $extraArgs = ""; if (defined($timeoutArgPattern) && $timeoutArgPattern ne "") { my $timeArg = $timeoutArgPattern; $timeoutArg =~ s//$timeout/; $extraArgs .= $timeoutArg } print STDOUT "Env includes $progEnv\n" if $verbose; print STDOUT "$mpiexec $np_arg $np $extraArgs $program_wrapper ./$programname $progArgs\n" if $verbose; print STDOUT "." if $showProgress; # Save and restore the environment if necessary before running mpiexec. if ($progEnv ne "") { # Need to fix: # save_NAME_is_set=is old name set # save_NAME=oldValue # export NAME=newvalue # (run) # export NAME=oldValue (if set!) print STDERR "Batch output does not permit changes to environment\n"; } # The approach here is to move the test codes to a single directory from # which they can be run; this avoids complex code to change directories # and ensure that the output goes "into the right place". $testCount++; rename $programname, "$batrundir/$programname"; print BATOUT "echo \"# $mpiexec $np_arg $np $extraArgs $mpiexecArgs $program_wrapper $curdir/$programname $progArgs\" > runtests.$testCount.out\n"; # Some programs expect to run in the same directory as the executable print BATOUT "$mpiexec $np_arg $np $extraArgs $mpiexecArgs $program_wrapper ./$programname $progArgs >> runtests.$testCount.out 2>&1\n"; print BATOUT "echo \$? > runtests.$testCount.status\n"; } # # Return value is 0 on success, non zero on failure sub BuildMPIProgram { my $programname = shift; if (! -x $programname) { die "Could not find $programname. Aborting.\n"; } return 0; # THE FOLLOWING IS DISABLED. my $xfail = shift; my $rc = 0; if ($verbose) { print STDERR "making $programname\n"; } if (! -x $programname) { $remove_this_pgm = 1; } else { $remove_this_pgm = 0; } my $output = `make $programname 2>&1`; $rc = $?; if ($rc > 255) { $rc >>= 8; } if (! -x $programname) { print STDERR "Failed to build $programname; $output\n"; if ($rc == 0) { $rc = 1; } # Add a line to the summary file describing the failure # This will ensure that failures to build will end up # in the summary file (which is otherwise written by the # RunMPIProgram step) &RunPreMsg( $programname, $np, $curdir ); &RunTestFailed( $programname, $np, $curdir, "Failed to build $programname; $output", $xfail ); &RunPostMsg( $programname, $np, $curdir ); } return $rc; } sub CleanUpAfterRun { my $programname = $_[0]; # Check for that this program has exited. If it is still running, # issue a warning and leave the application. Of course, this # check is complicated by the lack of a standard access to the # running processes for this user in Unix. @stillRunning = &FindRunning( $programname ); if ($#stillRunning > -1) { print STDERR "Some programs ($programname) may still be running:\npids = "; for (my $i=0; $i <= $#stillRunning; $i++ ) { print STDERR $stillRunning[$i] . " "; } print STDERR "\n"; # Remind the user that the executable remains; we leave it around # to allow the programmer to debug the running program, for which # the executable is needed. print STDERR "The executable ($programname) will not be removed.\n"; } else { if ($remove_this_pgm && $clean_pgms) { unlink $programname, "$programname.o"; } $remove_this_pgm = 0; } } # ---------------------------------------------------------------------------- sub FindRunning { my $programname = $_[0]; my @pids = (); my $logname = $ENV{'USER'}; my $pidloc = 1; my $rc = open PSFD, "ps auxw -U $logname 2>&1 |"; if ($rc == 0) { $rc = open PSFD, "ps -fu $logname 2>&1 |"; } if ($rc == 0) { print STDERR "Could not execute ps command\n"; return @pids; } while () { if (/$programname/) { @fields = split(/\s+/); my $pid = $fields[$pidloc]; # Check that we've found a numeric pid if ($pid =~ /^\d+$/) { $pids[$#pids + 1] = $pid; } } } close PSFD; return @pids; } # ---------------------------------------------------------------------------- # # TestStatus is a special test that reports success *only* when the # status return is NONZERO sub TestStatus { my $MPIOUT = $_[0]; my $programname = $_[1]; my $found_error = 0; my $inline = ""; while (<$MPIOUT>) { #print STDOUT $_ if $verbose; # Skip FORTRAN STOP if (/FORTRAN STOP/) { next; } $inline .= $_; # ANY output is an error. We have the following output # exception for the Hydra process manager. if (/=*/) { last; } if (! /^\s*$/) { print STDERR "Unexpected output in $programname: $_"; if (!$found_error) { $found_error = 1; $err_count ++; } } } $rc = close ( MPIOUT ); if ($rc == 0) { $run_status = $?; $signal_num = $run_status & 127; if ($run_status > 255) { $run_status >>= 8; } } else { # This test *requires* non-zero return codes if (!$found_error) { $found_error = 1; $err_count ++; } $inline .= "$mpiexec returned a zero status but the program returned a nonzero status\n"; } return ($found_error,$inline); } # # TestTimeout is a special test that reports success *only* when the # status return is NONZERO and there are no processes left over. # This test currently checks only for the return status. sub TestTimeout { my $MPIOUT = $_[0]; my $programname = $_[1]; my $found_error = 0; my $inline = ""; while (<$MPIOUT>) { #print STDOUT $_ if $verbose; # Skip FORTRAN STOP if (/FORTRAN STOP/) { next; } $inline .= $_; if (/[Tt]imeout/) { next; } # Allow 'signaled with Interrupt' (see gforker mpiexec) if (/signaled with Interrupt/) { next; } # Allow 'job ending due to env var MPIEXEC_TIMEOUT' (mpd) if (/job ending due to env var MPIEXEC_TIMEOUT/) { next; } # Allow 'APPLICATION TIMED OUT' (hydra) if (/\[mpiexec@.*\] APPLICATION TIMED OUT/) { last; } # ANY output is an error (other than timeout) if (! /^\s*$/) { print STDERR "Unexpected output in $programname: $_"; if (!$found_error) { $found_error = 1; $err_count ++; } } } $rc = close ( MPIOUT ); if ($rc == 0) { $run_status = $?; $signal_num = $run_status & 127; if ($run_status > 255) { $run_status >>= 8; } } else { # This test *requires* non-zero return codes if (!$found_error) { $found_error = 1; $err_count ++; } $inline .= "$mpiexec returned a zero status but the program returned a nonzero status\n"; } # # Here should go a check of the processes # open( PFD, "ps -fu $LOGNAME | grep -v grep | grep $programname |" ); # while () { # # } # close PFD; return ($found_error,$inline); } # # TestErrFatal is a special test that reports success *only* when the # status return is NONZERO; it ignores error messages sub TestErrFatal { my $MPIOUT = $_[0]; my $programname = $_[1]; my $found_error = 0; my $inline = ""; while (<$MPIOUT>) { #print STDOUT $_ if $verbose; # Skip FORTRAN STOP if (/FORTRAN STOP/) { next; } $inline .= $_; # ALL output is allowed. } $rc = close ( MPIOUT ); if ($rc == 0) { $run_status = $?; $signal_num = $run_status & 127; if ($run_status > 255) { $run_status >>= 8; } } else { # This test *requires* non-zero return codes if (!$found_error) { $found_error = 1; $err_count ++; } $inline .= "$mpiexec returned a zero status but the program returned a nonzero status\n"; } return ($found_error,$inline); } # ---------------------------------------------------------------------------- # Output routines: # RunPreMsg( programname, np, workdir ) - Call before running a program # RunTestFailed, RunTestPassed - Call after test # RunPostMsg - Call at end of each test # sub RunPreMsg { my ($programname,$np,$workdir) = @_; if ($xmloutput) { print XMLOUT "$newline$programname$newline"; print XMLOUT "$np$newline"; print XMLOUT "$workdir$newline"; } } sub RunPostMsg { my ($programname, $np, $workdir) = @_; if ($xmloutput) { print XMLOUT "$newline"; } } sub RunTestPassed { my ($programname, $np, $workdir, $xfail) = @_; if ($xmloutput) { print XMLOUT "pass$newline"; } if ($tapoutput) { my $xfailstr = ''; if ($xfail ne '') { $xfailstr = " # TODO $xfail"; } print TAPOUT "ok ${total_run} - $workdir/$programname ${np}${xfailstr}\n"; } } sub RunTestFailed { my $programname = shift; my $np = shift; my $workdir = shift; my $output = shift; my $xfail = shift; if ($xmloutput) { my $xout = $output; # basic escapes that wreck the XML output $xout =~ s//\*AMP\*gt;/g; $xout =~ s/&/\*AMP\*amp;/g; $xout =~ s/\*AMP\*/&/g; # TODO: Also capture any non-printing characters (XML doesn't like them # either). print XMLOUT "fail$newline"; print XMLOUT "$newline$xout$newline"; } if ($tapoutput) { my $xfailstr = ''; if ($xfail ne '') { $xfailstr = " # TODO $xfail"; } print TAPOUT "not ok ${total_run} - $workdir/$programname ${np}${xfailstr}\n"; print TAPOUT " ---\n"; print TAPOUT " Directory: $workdir\n"; print TAPOUT " File: $programname\n"; print TAPOUT " Num-procs: $np\n"; print TAPOUT " Date: \"" . localtime . "\"\n"; # The following would be nice, but it leads to unfortunate formatting in # the Jenkins web output for now. Using comment lines instead, since # they are easier to read/find in a browser. ## print TAPOUT " Output: |\n"; ## # using block literal format, requires that all chars are printable ## # UTF-8 (or UTF-16, but we won't encounter that) ## foreach my $line (split m/\r?\n/, $output) { ## chomp $line; ## # 4 spaces, 2 for TAP indent, 2 more for YAML block indent ## print TAPOUT " $line\n"; ## } print TAPOUT " ...\n"; # Alternative to the "Output:" YAML block literal above. Do not put any # spaces before the '#', this causes some TAP parsers (including Perl's # TAP::Parser) to treat the line as "unknown" instead of a proper # comment. print TAPOUT "## Test output (expected 'No Errors'):\n"; foreach my $line (split m/\r?\n/, $output) { chomp $line; print TAPOUT "## $line\n"; } } } sub SkippedTest { my $programname = shift; my $np = shift; my $workdir = shift; my $reason = shift; # simply omit from the XML output if ($tapoutput) { print TAPOUT "ok ${total_seen} - $workdir/$programname $np # SKIP $reason\n"; } } # ---------------------------------------------------------------------------- # Alternate init routines sub InitQuickTimeout { $ENV{"MPIEXEC_TIMEOUT"} = 10; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/000755 001750 001750 00000000000 12342443666 020135 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/fkeyvaltype.c000644 001750 001750 00000007146 12342443661 022647 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" #include "stdlib.h" /* static char MTestDescrip[] = "Test freeing keyvals while still attached to \ a datatype, then make sure that the keyval delete and copy code are still \ executed"; */ /* Copy increments the attribute value */ int copy_fn( MPI_Datatype oldtype, int keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag); int copy_fn( MPI_Datatype oldtype, int keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag) { /* Copy the address of the attribute */ *(void **)attribute_val_out = attribute_val_in; /* Change the value */ *(int *)attribute_val_in = *(int *)attribute_val_in + 1; /* set flag to 1 to tell comm dup to insert this attribute into the new communicator */ *flag = 1; return MPI_SUCCESS; } /* Delete decrements the attribute value */ int delete_fn( MPI_Datatype type, int keyval, void *attribute_val, void *extra_state); int delete_fn( MPI_Datatype type, int keyval, void *attribute_val, void *extra_state) { *(int *)attribute_val = *(int *)attribute_val - 1; return MPI_SUCCESS; } int main( int argc, char *argv[] ) { int errs = 0; int attrval; int i, key[32], keyval, saveKeyval; MPI_Datatype type, duptype; MTestDatatype mstype, mrtype; char typename[MPI_MAX_OBJECT_NAME]; int tnlen; MTest_Init( &argc, &argv ); while (MTestGetDatatypes( &mstype, &mrtype, 1 )) { type = mstype.datatype; MPI_Type_create_keyval( copy_fn, delete_fn, &keyval, (void *)0 ); saveKeyval = keyval; /* in case we need to free explicitly */ attrval = 1; MPI_Type_set_attr( type, keyval, (void*)&attrval ); /* See MPI-1, 5.7.1. Freeing the keyval does not remove it if it is in use in an attribute */ MPI_Type_free_keyval( &keyval ); /* We create some dummy keyvals here in case the same keyval is reused */ for (i=0; i<32; i++) { MPI_Type_create_keyval( MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &key[i], (void *)0 ); } if (attrval != 1) { errs++; MPI_Type_get_name( type, typename, &tnlen ); printf( "attrval is %d, should be 1, before dup in type %s\n", attrval, typename ); } MPI_Type_dup( type, &duptype ); /* Check that the attribute was copied */ if (attrval != 2) { errs++; MPI_Type_get_name( type, typename, &tnlen ); printf( "Attribute not incremented when type dup'ed (%s)\n", typename ); } MPI_Type_free( &duptype ); if (attrval != 1) { errs++; MPI_Type_get_name( type, typename, &tnlen ); printf( "Attribute not decremented when duptype %s freed\n", typename ); } /* Check that the attribute was freed in the duptype */ if (!mstype.isBasic) { MPI_Type_get_name( type, typename, &tnlen ); MTestFreeDatatype(&mstype); /* Check that the original attribute was freed */ if (attrval != 0) { errs++; printf( "Attribute not decremented when type %s freed\n", typename ); } } else { /* Explicitly delete the attributes from world and self */ MPI_Type_delete_attr( type, saveKeyval ); if (mstype.buf) { free(mstype.buf); mstype.buf = 0; } } /* Free those other keyvals */ for (i=0; i<32; i++) { MPI_Type_free_keyval( &key[i] ); } MTestFreeDatatype(&mrtype); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/attrordercomm.c000644 001750 001750 00000005557 12342443661 023172 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" /* static char MTestDescrip[] = "Test creating and inserting attributes in \ different orders to ensure that the list management code handles all cases."; */ int checkAttrs( MPI_Comm comm, int n, int key[], int attrval[] ); int checkNoAttrs( MPI_Comm comm, int n, int key[] ); int main( int argc, char *argv[] ) { int errs = 0; int key[3], attrval[3]; int i; MPI_Comm comm; MTest_Init( &argc, &argv ); { comm = MPI_COMM_WORLD; /* Create key values */ for (i=0; i<3; i++) { MPI_Comm_create_keyval( MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &key[i], (void *)0 ); attrval[i] = 1024 * i; } /* Insert attribute in several orders. Test after put with get, then delete, then confirm delete with get. */ MPI_Comm_set_attr( comm, key[2], &attrval[2] ); MPI_Comm_set_attr( comm, key[1], &attrval[1] ); MPI_Comm_set_attr( comm, key[0], &attrval[0] ); errs += checkAttrs( comm, 3, key, attrval ); MPI_Comm_delete_attr( comm, key[0] ); MPI_Comm_delete_attr( comm, key[1] ); MPI_Comm_delete_attr( comm, key[2] ); errs += checkNoAttrs( comm, 3, key ); MPI_Comm_set_attr( comm, key[1], &attrval[1] ); MPI_Comm_set_attr( comm, key[2], &attrval[2] ); MPI_Comm_set_attr( comm, key[0], &attrval[0] ); errs += checkAttrs( comm, 3, key, attrval ); MPI_Comm_delete_attr( comm, key[2] ); MPI_Comm_delete_attr( comm, key[1] ); MPI_Comm_delete_attr( comm, key[0] ); errs += checkNoAttrs( comm, 3, key ); MPI_Comm_set_attr( comm, key[0], &attrval[0] ); MPI_Comm_set_attr( comm, key[1], &attrval[1] ); MPI_Comm_set_attr( comm, key[2], &attrval[2] ); errs += checkAttrs( comm, 3, key, attrval ); MPI_Comm_delete_attr( comm, key[1] ); MPI_Comm_delete_attr( comm, key[2] ); MPI_Comm_delete_attr( comm, key[0] ); errs += checkNoAttrs( comm, 3, key ); for (i=0; i<3; i++) { MPI_Comm_free_keyval( &key[i] ); } } MTest_Finalize( errs ); MPI_Finalize(); return 0; } int checkAttrs( MPI_Comm comm, int n, int key[], int attrval[] ) { int errs = 0; int i, flag, *val_p; for (i=0; i #include "mpi.h" #include "mpitest.h" int test_attrs ( void ); void abort_msg ( const char *, int ); int copybomb_fn ( MPI_Datatype, int, void *, void *, void *, int * ); int deletebomb_fn ( MPI_Datatype, int, void *, void * ); int main( int argc, char **argv ) { int errs; MTest_Init( &argc, &argv ); errs = test_attrs(); MTest_Finalize( errs ); MPI_Finalize(); return 0; } /* * MPI 1.2 Clarification: Clarification of Error Behavior of * Attribute Callback Functions * Any return value other than MPI_SUCCESS is erroneous. The specific value * returned to the user is undefined (other than it can't be MPI_SUCCESS). * Proposals to specify particular values (e.g., user's value) failed. */ /* Return an error as the value */ int copybomb_fn( MPI_Datatype oldtype, int keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag) { /* Note that if (sizeof(int) < sizeof(void *), just setting the int part of attribute_val_out may leave some dirty bits */ *flag = 1; return MPI_ERR_OTHER; } /* Set delete flag to 1 to allow the attribute to be deleted */ static int delete_flag = 0; static int deleteCalled = 0; int deletebomb_fn( MPI_Datatype type, int keyval, void *attribute_val, void *extra_state) { deleteCalled ++; if (delete_flag) return MPI_SUCCESS; return MPI_ERR_OTHER; } void abort_msg( const char *str, int code ) { fprintf( stderr, "%s, err = %d\n", str, code ); MPI_Abort( MPI_COMM_WORLD, code ); exit(code); } int test_attrs( void ) { MPI_Datatype dup_type, d2; int world_rank, world_size, key_1; int err, errs = 0; MPI_Aint value; MPI_Comm_rank( MPI_COMM_WORLD, &world_rank ); MPI_Comm_size( MPI_COMM_WORLD, &world_size ); #ifdef DEBUG if (world_rank == 0) { printf( "*** Attribute copy/delete return codes ***\n" ); } #endif MPI_Type_dup( MPI_DOUBLE, &dup_type ); MPI_Errhandler_set( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); value = - 11; if ((err=MPI_Type_create_keyval( copybomb_fn, deletebomb_fn, &key_1, &value ))) abort_msg( "Keyval_create", err ); err = MPI_Type_set_attr( dup_type, key_1, (void *) (MPI_Aint) world_rank ); if (err) { errs++; printf( "Error with first put\n" ); } err = MPI_Type_set_attr( dup_type, key_1, (void *) (MPI_Aint) (2*world_rank) ); if (err == MPI_SUCCESS) { errs++; printf( "delete function return code was MPI_SUCCESS in put\n" ); } /* Because the attribute delete function should fail, the attribute should *not be removed* */ err = MPI_Type_delete_attr( dup_type, key_1 ); if (err == MPI_SUCCESS) { errs++; printf( "delete function return code was MPI_SUCCESS in delete\n" ); } err = MPI_Type_dup( dup_type, &d2 ); if (err == MPI_SUCCESS) { errs++; printf( "copy function return code was MPI_SUCCESS in dup\n" ); } #ifndef USE_STRICT_MPI /* Another interpretation is to leave d2 unchanged on error */ if (err && d2 != MPI_DATATYPE_NULL) { errs++; printf( "dup did not return MPI_DATATYPE_NULL on error\n" ); } #endif delete_flag = 1; deleteCalled = 0; if (d2 != MPI_DATATYPE_NULL) MPI_Type_free(&d2); MPI_Type_free( &dup_type ); if (deleteCalled == 0) { errs++; printf( "Free of a datatype did not invoke the attribute delete routine\n" ); } MPI_Type_free_keyval( &key_1 ); return errs; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/keyval_double_free.c000644 001750 001750 00000002271 12342443661 024124 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2009 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include #include "mpitest.h" /* tests multiple invocations of Keyval_free on the same keyval */ int delete_fn(MPI_Comm comm, int keyval, void *attr, void *extra); int delete_fn(MPI_Comm comm, int keyval, void *attr, void *extra) { MPI_Keyval_free(&keyval); return MPI_SUCCESS; } int main (int argc, char **argv) { MPI_Comm duped; int keyval = MPI_KEYVAL_INVALID; int keyval_copy = MPI_KEYVAL_INVALID; int errs=0; MTest_Init( &argc, &argv ); MPI_Comm_dup(MPI_COMM_SELF, &duped); MPI_Keyval_create(MPI_NULL_COPY_FN, delete_fn, &keyval, NULL); keyval_copy = keyval; MPI_Attr_put(MPI_COMM_SELF, keyval, NULL); MPI_Attr_put(duped, keyval, NULL); MPI_Comm_free(&duped); /* first MPI_Keyval_free */ MPI_Keyval_free(&keyval); /* second MPI_Keyval_free */ MPI_Keyval_free(&keyval_copy); /* third MPI_Keyval_free */ MTest_Finalize( errs ); MPI_Finalize(); /* fourth MPI_Keyval_free */ return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/attrend.c000644 001750 001750 00000003674 12342443660 021746 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2008 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* The MPI-2 specification makes it clear that delect attributes are called on MPI_COMM_WORLD and MPI_COMM_SELF at the very beginning of MPI_Finalize. This is useful for tools that want to perform the MPI equivalent of an "at_exit" action. */ #include #include "mpi.h" #include "mpitest.h" int exit_key = MPI_KEYVAL_INVALID; int wasCalled = 0; int foundError = 0; /* #define DEBUG */ int delete_fn ( MPI_Comm, int, void *, void * ); #ifdef DEBUG #define FFLUSH fflush(stdout); #else #define FFLUSH #endif int main( int argc, char **argv ) { int errs = 0, wrank; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); /* create the keyval for the exit handler */ MPI_Keyval_create( MPI_NULL_COPY_FN, delete_fn, &exit_key, (void *)0 ); /* Attach to comm_self */ MPI_Attr_put( MPI_COMM_SELF, exit_key, (void*)0 ); /* We can free the key now */ MPI_Keyval_free( &exit_key ); /* Now, exit MPI */ /* MTest_Finalize( errs ); */ MPI_Finalize(); /* Check that the exit handler was called, and without error */ if (wrank == 0) { /* In case more than one process exits MPI_Finalize */ if (wasCalled != 1) { errs++; printf( "Attribute delete function on MPI_COMM_SELF was not called\n" ); } if (foundError != 0) { errs++; printf( "Found %d errors while executing delete function in MPI_COMM_SELF\n", foundError ); } if (errs == 0) { printf( " No Errors\n" ); } else { printf( " Found %d errors\n", errs ); } fflush(stdout ); } return 0; } int delete_fn( MPI_Comm comm, int keyval, void *attribute_val, void *extra_state) { int flag; wasCalled++; MPI_Finalized( &flag ); if (flag) { foundError++; } return MPI_SUCCESS; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/attrorder.c000644 001750 001750 00000005401 12342443661 022302 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" /* static char MTestDescrip[] = "Test creating and inserting attributes in \ different orders to ensure that the list management code handles all cases."; */ int checkAttrs( MPI_Comm comm, int n, int key[], int attrval[] ); int checkNoAttrs( MPI_Comm comm, int n, int key[] ); int main( int argc, char *argv[] ) { int errs = 0; int key[3], attrval[3]; int i; MPI_Comm comm; MTest_Init( &argc, &argv ); { comm = MPI_COMM_WORLD; /* Create key values */ for (i=0; i<3; i++) { MPI_Keyval_create( MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &key[i], (void *)0 ); attrval[i] = 1024 * i; } /* Insert attribute in several orders. Test after put with get, then delete, then confirm delete with get. */ MPI_Attr_put( comm, key[2], &attrval[2] ); MPI_Attr_put( comm, key[1], &attrval[1] ); MPI_Attr_put( comm, key[0], &attrval[0] ); errs += checkAttrs( comm, 3, key, attrval ); MPI_Attr_delete( comm, key[0] ); MPI_Attr_delete( comm, key[1] ); MPI_Attr_delete( comm, key[2] ); errs += checkNoAttrs( comm, 3, key ); MPI_Attr_put( comm, key[1], &attrval[1] ); MPI_Attr_put( comm, key[2], &attrval[2] ); MPI_Attr_put( comm, key[0], &attrval[0] ); errs += checkAttrs( comm, 3, key, attrval ); MPI_Attr_delete( comm, key[2] ); MPI_Attr_delete( comm, key[1] ); MPI_Attr_delete( comm, key[0] ); errs += checkNoAttrs( comm, 3, key ); MPI_Attr_put( comm, key[0], &attrval[0] ); MPI_Attr_put( comm, key[1], &attrval[1] ); MPI_Attr_put( comm, key[2], &attrval[2] ); errs += checkAttrs( comm, 3, key, attrval ); MPI_Attr_delete( comm, key[1] ); MPI_Attr_delete( comm, key[2] ); MPI_Attr_delete( comm, key[0] ); errs += checkNoAttrs( comm, 3, key ); for (i=0; i<3; i++) { MPI_Keyval_free( &key[i] ); } } MTest_Finalize( errs ); MPI_Finalize(); return 0; } int checkAttrs( MPI_Comm comm, int n, int key[], int attrval[] ) { int errs = 0; int i, flag, *val_p; for (i=0; i #include "mpi.h" #include "mpitest.h" int test_communicators ( void ); void abort_msg ( const char *, int ); int copybomb_fn ( MPI_Comm, int, void *, void *, void *, int * ); int deletebomb_fn ( MPI_Comm, int, void *, void * ); int main( int argc, char **argv ) { int errs; MTest_Init( &argc, &argv ); errs = test_communicators(); MTest_Finalize( errs ); MPI_Finalize(); return 0; } /* * MPI 1.2 Clarification: Clarification of Error Behavior of * Attribute Callback Functions * Any return value other than MPI_SUCCESS is erroneous. The specific value * returned to the user is undefined (other than it can't be MPI_SUCCESS). * Proposals to specify particular values (e.g., user's value) failed. */ /* Return an error as the value */ int copybomb_fn( MPI_Comm oldcomm, int keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag) { /* Note that if (sizeof(int) < sizeof(void *), just setting the int part of attribute_val_out may leave some dirty bits */ *flag = 1; return MPI_ERR_OTHER; } /* Set delete flag to 1 to allow the attribute to be deleted */ static int delete_flag = 0; int deletebomb_fn( MPI_Comm comm, int keyval, void *attribute_val, void *extra_state) { if (delete_flag) return MPI_SUCCESS; return MPI_ERR_OTHER; } void abort_msg( const char *str, int code ) { fprintf( stderr, "%s, err = %d\n", str, code ); MPI_Abort( MPI_COMM_WORLD, code ); exit(code); } int test_communicators( void ) { MPI_Comm dup_comm_world, d2; int world_rank, world_size, key_1; int err, errs = 0; MPI_Aint value; MPI_Comm_rank( MPI_COMM_WORLD, &world_rank ); MPI_Comm_size( MPI_COMM_WORLD, &world_size ); #ifdef DEBUG if (world_rank == 0) { printf( "*** Attribute copy/delete return codes ***\n" ); } #endif MPI_Comm_dup( MPI_COMM_WORLD, &dup_comm_world ); MPI_Barrier( dup_comm_world ); MPI_Errhandler_set( dup_comm_world, MPI_ERRORS_RETURN ); value = - 11; if ((err=MPI_Comm_create_keyval( copybomb_fn, deletebomb_fn, &key_1, &value ))) abort_msg( "Keyval_create", err ); err = MPI_Comm_set_attr( dup_comm_world, key_1, (void *) (MPI_Aint) world_rank ); if (err) { errs++; printf( "Error with first put\n" ); } err = MPI_Comm_set_attr( dup_comm_world, key_1, (void *) (MPI_Aint) (2*world_rank) ); if (err == MPI_SUCCESS) { errs++; printf( "delete function return code was MPI_SUCCESS in put\n" ); } /* Because the attribute delete function should fail, the attribute should *not be removed* */ err = MPI_Comm_delete_attr( dup_comm_world, key_1 ); if (err == MPI_SUCCESS) { errs++; printf( "delete function return code was MPI_SUCCESS in delete\n" ); } err = MPI_Comm_dup( dup_comm_world, &d2 ); if (err == MPI_SUCCESS) { errs++; printf( "copy function return code was MPI_SUCCESS in dup\n" ); } if (err != MPI_ERR_OTHER) { int lerrclass; MPI_Error_class( err, &lerrclass ); if (lerrclass != MPI_ERR_OTHER) { errs++; printf( "dup did not return an error code of class ERR_OTHER; " ); printf( "err = %d, class = %d\n", err, lerrclass ); } } #ifndef USE_STRICT_MPI /* Another interpretation is to leave d2 unchanged on error */ if (err && d2 != MPI_COMM_NULL) { errs++; printf( "dup did not return MPI_COMM_NULL on error\n" ); } #endif delete_flag = 1; MPI_Comm_free( &dup_comm_world ); MPI_Comm_free_keyval( &key_1 ); return errs; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/attrend2.c000644 001750 001750 00000007752 12342443660 022031 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2008 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* The MPI-2.2 specification makes it clear that attributes are called on MPI_COMM_WORLD and MPI_COMM_SELF at the very beginning of MPI_Finalize in LIFO order with respect to the order in which they are set. This is useful for tools that want to perform the MPI equivalent of an "at_exit" action. */ #include #include "mpi.h" #include "mpitest.h" /* 20 ought to be enough attributes to ensure that hash-table based MPI * implementations do not accidentally pass the test except by being extremely * "lucky". There are (20!) possible permutations which means that there is * about a 1 in 2.43e18 chance of getting LIFO ordering out of a hash table, * assuming a decent hash function is used. */ #define NUM_TEST_ATTRS (20) static __attribute__((unused)) int exit_keys[NUM_TEST_ATTRS]; /* init to MPI_KEYVAL_INVALID */ static __attribute__((unused)) int was_called[NUM_TEST_ATTRS]; int foundError = 0; int delete_fn (MPI_Comm, int, void *, void *); int main(int argc, char **argv) { int wrank; MTest_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &wrank); #if MTEST_HAVE_MIN_MPI_VERSION(2,2) int errs = 0, wrank; int i; for (i = 0; i < NUM_TEST_ATTRS; ++i) { exit_keys[i] = MPI_KEYVAL_INVALID; was_called[i] = 0; /* create the keyval for the exit handler */ MPI_Comm_create_keyval(MPI_COMM_NULL_COPY_FN, delete_fn, &exit_keys[i], NULL); /* attach to comm_self */ MPI_Comm_set_attr(MPI_COMM_SELF, exit_keys[i], (void*)(long)i); } /* we can free the keys now */ for (i = 0; i < NUM_TEST_ATTRS; ++i) { MPI_Comm_free_keyval(&exit_keys[i]); } /* now, exit MPI */ MPI_Finalize(); /* check that the exit handlers were called in LIFO order, and without error */ if (wrank == 0) { /* In case more than one process exits MPI_Finalize */ for (i = 0; i < NUM_TEST_ATTRS; ++i) { if (was_called[i] < 1) { errs++; printf("Attribute delete function on MPI_COMM_SELF was not called for idx=%d\n", i); } else if (was_called[i] > 1) { errs++; printf("Attribute delete function on MPI_COMM_SELF was called multiple times for idx=%d\n", i); } } if (foundError != 0) { errs++; printf("Found %d errors while executing delete function in MPI_COMM_SELF\n", foundError); } if (errs == 0) { printf(" No Errors\n"); } else { printf(" Found %d errors\n", errs); } fflush(stdout); } #else /* this is a pre-MPI-2.2 implementation, ordering is not defined */ MPI_Finalize(); if (wrank == 0) printf(" No Errors\n"); #endif return 0; } int delete_fn(MPI_Comm comm, int keyval, void *attribute_val, void *extra_state) { int flag; int i; int my_idx = (int)(long)attribute_val; if (my_idx < 0 || my_idx > NUM_TEST_ATTRS) { printf("internal error, my_idx=%d is invalid!\n", my_idx); fflush(stdout); } was_called[my_idx]++; MPI_Finalized(&flag); if (flag) { printf("my_idx=%d, MPI_Finalized returned %d, should have been 0", my_idx, flag); foundError++; } /* since attributes were added in 0..(NUM_TEST_ATTRS-1) order, they will be * called in (NUM_TEST_ATTRS-1)..0 order */ for (i = 0; i < my_idx; ++i) { if (was_called[i] != 0) { printf("my_idx=%d, was_called[%d]=%d but should be 0\n", my_idx, i, was_called[i]); foundError++; } } for (i = my_idx; i < NUM_TEST_ATTRS; ++i) { if (was_called[i] != 1) { printf("my_idx=%d, was_called[%d]=%d but should be 1\n", my_idx, i, was_called[i]); foundError++; } } return MPI_SUCCESS; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/baseattrcomm.c000644 001750 001750 00000006203 12342443661 022756 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include "mpi.h" #include "mpitest.h" int main( int argc, char **argv) { int errs = 0; void *v; int flag; int vval; int rank, size; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_get_attr( MPI_COMM_WORLD, MPI_TAG_UB, &v, &flag ); if (!flag) { errs++; fprintf( stderr, "Could not get TAG_UB\n" ); } else { vval = *(int*)v; if (vval < 32767) { errs++; fprintf( stderr, "Got too-small value (%d) for TAG_UB\n", vval ); } } MPI_Comm_get_attr( MPI_COMM_WORLD, MPI_HOST, &v, &flag ); if (!flag) { errs++; fprintf( stderr, "Could not get HOST\n" ); } else { vval = *(int*)v; if ((vval < 0 || vval >= size) && vval != MPI_PROC_NULL) { errs++; fprintf( stderr, "Got invalid value %d for HOST\n", vval ); } } MPI_Comm_get_attr( MPI_COMM_WORLD, MPI_IO, &v, &flag ); if (!flag) { errs++; fprintf( stderr, "Could not get IO\n" ); } else { vval = *(int*)v; if ((vval < 0 || vval >= size) && vval != MPI_ANY_SOURCE && vval != MPI_PROC_NULL) { errs++; fprintf( stderr, "Got invalid value %d for IO\n", vval ); } } MPI_Comm_get_attr( MPI_COMM_WORLD, MPI_WTIME_IS_GLOBAL, &v, &flag ); if (flag) { /* Wtime need not be set */ vval = *(int*)v; if (vval < 0 || vval > 1) { errs++; fprintf( stderr, "Invalid value for WTIME_IS_GLOBAL (got %d)\n", vval ); } } /* MPI 2.0, section 5.5.3 - MPI_APPNUM should be set if the program is started with more than one executable name (e.g., in MPMD instead of SPMD mode). This is independent of the dynamic process routines, and should be supported even if MPI_COMM_SPAWN and friends are not. */ MPI_Comm_get_attr( MPI_COMM_WORLD, MPI_APPNUM, &v, &flag ); /* appnum need not be set */ if (flag) { vval = *(int *)v; if (vval < 0) { errs++; fprintf( stderr, "MPI_APPNUM is defined as %d but must be nonnegative\n", vval ); } } /* MPI 2.0 section 5.5.1. MPI_UNIVERSE_SIZE need not be set, but should be present. */ MPI_Comm_get_attr( MPI_COMM_WORLD, MPI_UNIVERSE_SIZE, &v, &flag ); /* MPI_UNIVERSE_SIZE need not be set */ if (flag) { /* But if it is set, it must be at least the size of comm_world */ vval = *(int *)v; if (vval < size) { errs++; fprintf( stderr, "MPI_UNIVERSE_SIZE = %d, less than comm world (%d)\n", vval, size ); } } MPI_Comm_get_attr( MPI_COMM_WORLD, MPI_LASTUSEDCODE, &v, &flag ); /* Last used code must be defined and >= MPI_ERR_LASTCODE */ if (flag) { vval = *(int*)v; if (vval < MPI_ERR_LASTCODE) { errs++; fprintf( stderr, "MPI_LASTUSEDCODE points to an integer (%d) smaller than MPI_ERR_LASTCODE (%d)\n", vval, MPI_ERR_LASTCODE ); } } else { errs++; fprintf( stderr, "MPI_LASTUSECODE is not defined\n" ); } MTest_Finalize( errs ); MPI_Finalize( ); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/baseattr2.c000644 001750 001750 00000007563 12342443661 022176 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include "mpi.h" #include "mpitest.h" void MissingKeyval( int rc, const char keyname[] ); int main( int argc, char **argv) { int errs = 0; int rc; void *v; int flag; int vval; int rank, size; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); /* Set errors return so that we can provide better information should a routine reject one of the attribute values */ MPI_Errhandler_set( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); rc = MPI_Attr_get( MPI_COMM_WORLD, MPI_TAG_UB, &v, &flag ); if (rc) { MissingKeyval( rc, "MPI_TAG_UB" ); errs++; } else { if (!flag) { errs++; fprintf( stderr, "Could not get TAG_UB\n" ); } else { vval = *(int*)v; if (vval < 32767) { errs++; fprintf( stderr, "Got too-small value (%d) for TAG_UB\n", vval ); } } } rc = MPI_Attr_get( MPI_COMM_WORLD, MPI_HOST, &v, &flag ); if (rc) { MissingKeyval( rc, "MPI_HOST" ); errs++; } else { if (!flag) { errs++; fprintf( stderr, "Could not get HOST\n" ); } else { vval = *(int*)v; if ((vval < 0 || vval >= size) && vval != MPI_PROC_NULL) { errs++; fprintf( stderr, "Got invalid value %d for HOST\n", vval ); } } } rc = MPI_Attr_get( MPI_COMM_WORLD, MPI_IO, &v, &flag ); if (rc) { MissingKeyval( rc, "MPI_IO" ); errs++; } else { if (!flag) { errs++; fprintf( stderr, "Could not get IO\n" ); } else { vval = *(int*)v; if ((vval < 0 || vval >= size) && vval != MPI_ANY_SOURCE && vval != MPI_PROC_NULL) { errs++; fprintf( stderr, "Got invalid value %d for IO\n", vval ); } } } rc = MPI_Attr_get( MPI_COMM_WORLD, MPI_WTIME_IS_GLOBAL, &v, &flag ); if (rc) { MissingKeyval( rc, "MPI_WTIME_IS_GLOBAL" ); errs++; } else { if (flag) { /* Wtime need not be set */ vval = *(int*)v; if (vval < 0 || vval > 1) { errs++; fprintf( stderr, "Invalid value for WTIME_IS_GLOBAL (got %d)\n", vval ); } } } rc = MPI_Attr_get( MPI_COMM_WORLD, MPI_APPNUM, &v, &flag ); if (rc) { MissingKeyval( rc, "MPI_APPNUM" ); errs++; } else { /* appnum need not be set */ if (flag) { vval = *(int *)v; if (vval < 0) { errs++; fprintf( stderr, "MPI_APPNUM is defined as %d but must be nonnegative\n", vval ); } } } rc = MPI_Attr_get( MPI_COMM_WORLD, MPI_UNIVERSE_SIZE, &v, &flag ); if (rc) { MissingKeyval( rc, "MPI_UNIVERSE_SIZE" ); errs++; } else { /* MPI_UNIVERSE_SIZE need not be set */ if (flag) { vval = *(int *)v; if (vval < size) { errs++; fprintf( stderr, "MPI_UNIVERSE_SIZE = %d, less than comm world (%d)\n", vval, size ); } } } rc = MPI_Attr_get( MPI_COMM_WORLD, MPI_LASTUSEDCODE, &v, &flag ); if (rc) { MissingKeyval( rc, "MPI_LASTUSEDCODE" ); errs++; } else { /* Last used code must be defined and >= MPI_ERR_LASTCODE */ if (flag) { vval = *(int*)v; if (vval < MPI_ERR_LASTCODE) { errs++; fprintf( stderr, "MPI_LASTUSEDCODE points to an integer (%d) smaller than MPI_ERR_LASTCODE (%d)\n", vval, MPI_ERR_LASTCODE ); } } else { errs++; fprintf( stderr, "MPI_LASTUSECODE is not defined\n" ); } } MPI_Errhandler_set( MPI_COMM_WORLD, MPI_ERRORS_ARE_FATAL ); MTest_Finalize( errs ); MPI_Finalize( ); return 0; } void MissingKeyval( int errcode, const char keyname[] ) { int errclass, slen; char string[MPI_MAX_ERROR_STRING]; MPI_Error_class( errcode, &errclass ); MPI_Error_string( errcode, string, &slen ); printf( "For key %s: Error class %d (%s)\n", keyname, errclass, string ); fflush( stdout ); } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/attric.c000644 001750 001750 00000010452 12342443661 021564 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* Exercise communicator routines for intercommunicators This C version derived from attrt, which in turn was derived from a Fortran test program from ... */ #include #include "mpi.h" #include "mpitest.h" /* #define DEBUG */ int test_communicators ( void ); int copy_fn ( MPI_Comm, int, void *, void *, void *, int * ); int delete_fn ( MPI_Comm, int, void *, void * ); #ifdef DEBUG #define FFLUSH fflush(stdout); #else #define FFLUSH #endif int main( int argc, char **argv ) { int errs = 0; MTest_Init( &argc, &argv ); errs = test_communicators(); MTest_Finalize( errs ); MPI_Finalize(); return 0; } int copy_fn( MPI_Comm oldcomm, int keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag) { /* Note that if (sizeof(int) < sizeof(void *), just setting the int part of attribute_val_out may leave some dirty bits */ *(MPI_Aint *)attribute_val_out = (MPI_Aint)attribute_val_in; *flag = 1; return MPI_SUCCESS; } int delete_fn( MPI_Comm comm, int keyval, void *attribute_val, void *extra_state) { int world_rank; MPI_Comm_rank( MPI_COMM_WORLD, &world_rank ); if ((MPI_Aint)attribute_val != (MPI_Aint)world_rank) { printf( "incorrect attribute value %d\n", *(int*)attribute_val ); MPI_Abort(MPI_COMM_WORLD, 1005 ); exit(1005); } return MPI_SUCCESS; } int test_communicators( void ) { MPI_Comm dup_comm, comm; void *vvalue; int flag, world_rank, world_size, key_1, key_3; int errs = 0; MPI_Aint value; int isLeft; MPI_Comm_rank( MPI_COMM_WORLD, &world_rank ); MPI_Comm_size( MPI_COMM_WORLD, &world_size ); #ifdef DEBUG if (world_rank == 0) { printf( "*** Communicators ***\n" ); fflush(stdout); } #endif while (MTestGetIntercomm( &comm, &isLeft, 2 )) { MTestPrintfMsg(1, "start while loop, isLeft=%s\n", (isLeft ? "TRUE" : "FALSE")); if (comm == MPI_COMM_NULL) { MTestPrintfMsg(1, "got COMM_NULL, skipping\n"); continue; } /* Check Comm_dup by adding attributes to comm & duplicating */ value = 9; MPI_Keyval_create(copy_fn, delete_fn, &key_1, &value ); MTestPrintfMsg(1, "Keyval_create key=%#x value=%d\n", key_1, value); value = 7; MPI_Keyval_create(MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &key_3, &value ); MTestPrintfMsg(1, "Keyval_create key=%#x value=%d\n", key_3, value); /* This may generate a compilation warning; it is, however, an easy way to cache a value instead of a pointer */ /* printf( "key1 = %x key3 = %x\n", key_1, key_3 ); */ MPI_Attr_put(comm, key_1, (void *) (MPI_Aint) world_rank ); MPI_Attr_put(comm, key_3, (void *)0 ); MTestPrintfMsg(1, "Comm_dup\n" ); MPI_Comm_dup(comm, &dup_comm ); /* Note that if sizeof(int) < sizeof(void *), we can't use (void **)&value to get the value we passed into Attr_put. To avoid problems (e.g., alignment errors), we recover the value into a (void *) and cast to int. Note that this may generate warning messages from the compiler. */ MPI_Attr_get(dup_comm, key_1, (void **)&vvalue, &flag ); value = (MPI_Aint)vvalue; if (! flag) { errs++; printf( "dup_comm key_1 not found on %d\n", world_rank ); fflush( stdout ); MPI_Abort(MPI_COMM_WORLD, 3004 ); exit(3004); } if (value != world_rank) { errs++; printf( "dup_comm key_1 value incorrect: %ld\n", (long)value ); fflush( stdout ); MPI_Abort(MPI_COMM_WORLD, 3005 ); exit(3005); } MPI_Attr_get(dup_comm, key_3, (void **)&vvalue, &flag ); value = (MPI_Aint)vvalue; if (flag) { errs++; printf( "dup_comm key_3 found!\n" ); fflush( stdout ); MPI_Abort(MPI_COMM_WORLD, 3008 ); exit(3008); } MTestPrintfMsg(1, "Keyval_free key=%#x\n", key_1); MPI_Keyval_free(&key_1 ); MTestPrintfMsg(1, "Keyval_free key=%#x\n", key_3); MPI_Keyval_free(&key_3 ); /* Free all communicators created */ MTestPrintfMsg(1, "Comm_free comm\n"); MPI_Comm_free( &comm ); MTestPrintfMsg(1, "Comm_free dup_comm\n"); MPI_Comm_free( &dup_comm ); } return errs; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/attrerr.c000644 001750 001750 00000007116 12342443661 021764 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* Exercise attribute routines. This version checks for correct behavior of the copy and delete functions on an attribute, particularly the correct behavior when the routine returns failure. */ #include #include "mpi.h" #include "mpitest.h" int test_communicators ( void ); void abort_msg ( const char *, int ); int copybomb_fn ( MPI_Comm, int, void *, void *, void *, int * ); int deletebomb_fn ( MPI_Comm, int, void *, void * ); int main( int argc, char **argv ) { int errs; MTest_Init( &argc, &argv ); errs = test_communicators(); MTest_Finalize( errs ); MPI_Finalize(); return 0; } /* * MPI 1.2 Clarification: Clarification of Error Behavior of * Attribute Callback Functions * Any return value other than MPI_SUCCESS is erroneous. The specific value * returned to the user is undefined (other than it can't be MPI_SUCCESS). * Proposals to specify particular values (e.g., user's value) failed. */ /* Return an error as the value */ int copybomb_fn( MPI_Comm oldcomm, int keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag) { /* Note that if (sizeof(int) < sizeof(void *), just setting the int part of attribute_val_out may leave some dirty bits */ *flag = 1; return MPI_ERR_OTHER; } /* Set delete flag to 1 to allow the attribute to be deleted */ static int delete_flag = 0; int deletebomb_fn( MPI_Comm comm, int keyval, void *attribute_val, void *extra_state) { if (delete_flag) return MPI_SUCCESS; return MPI_ERR_OTHER; } void abort_msg( const char *str, int code ) { fprintf( stderr, "%s, err = %d\n", str, code ); MPI_Abort( MPI_COMM_WORLD, code ); exit(code); } int test_communicators( void ) { MPI_Comm dup_comm_world, d2; int world_rank, world_size, key_1; int err, errs = 0; MPI_Aint value; MPI_Comm_rank( MPI_COMM_WORLD, &world_rank ); MPI_Comm_size( MPI_COMM_WORLD, &world_size ); #ifdef DEBUG if (world_rank == 0) { printf( "*** Attribute copy/delete return codes ***\n" ); } #endif MPI_Comm_dup( MPI_COMM_WORLD, &dup_comm_world ); MPI_Barrier( dup_comm_world ); MPI_Errhandler_set( dup_comm_world, MPI_ERRORS_RETURN ); value = - 11; if ((err=MPI_Keyval_create( copybomb_fn, deletebomb_fn, &key_1, &value ))) abort_msg( "Keyval_create", err ); err = MPI_Attr_put( dup_comm_world, key_1, (void *) (MPI_Aint) world_rank ); if (err) { errs++; printf( "Error with first put\n" ); } err = MPI_Attr_put( dup_comm_world, key_1, (void *) (MPI_Aint) (2*world_rank) ); if (err == MPI_SUCCESS) { errs++; printf( "delete function return code was MPI_SUCCESS in put\n" ); } /* Because the attribute delete function should fail, the attribute should *not be removed* */ err = MPI_Attr_delete( dup_comm_world, key_1 ); if (err == MPI_SUCCESS) { errs++; printf( "delete function return code was MPI_SUCCESS in delete\n" ); } err = MPI_Comm_dup( dup_comm_world, &d2 ); if (err == MPI_SUCCESS) { errs++; printf( "copy function return code was MPI_SUCCESS in dup\n" ); } #ifndef USE_STRICT_MPI /* Another interpretation is to leave d2 unchanged on error */ if (err && d2 != MPI_COMM_NULL) { errs++; printf( "dup did not return MPI_COMM_NULL on error\n" ); } #endif delete_flag = 1; MPI_Comm_free( &dup_comm_world ); MPI_Keyval_free( &key_1 ); return errs; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/attrt.c000644 001750 001750 00000020216 12342443661 021433 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ /* Exercise communicator routines. This C version derived from a Fortran test program from .... */ #include #include "mpi.h" #include "mpitest.h" //#define DEBUG int test_communicators ( void ); int copy_fn ( MPI_Comm, int, void *, void *, void *, int * ); int delete_fn ( MPI_Comm, int, void *, void * ); #ifdef DEBUG #define FFLUSH fflush(stdout); #else #define FFLUSH #endif int main( int argc, char **argv ) { int errs = 0; MTest_Init( &argc, &argv ); errs = test_communicators(); MTest_Finalize( errs ); MPI_Finalize(); return 0; } int copy_fn( MPI_Comm oldcomm, int keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag) { /* Note that if (sizeof(int) < sizeof(void *), just setting the int part of attribute_val_out may leave some dirty bits */ *(MPI_Aint *)attribute_val_out = (MPI_Aint)attribute_val_in; *flag = 1; return MPI_SUCCESS; } int delete_fn( MPI_Comm comm, int keyval, void *attribute_val, void *extra_state) { int world_rank; MPI_Comm_rank( MPI_COMM_WORLD, &world_rank ); if ((MPI_Aint)attribute_val != (MPI_Aint)world_rank) { printf( "incorrect attribute value %d\n", *(int*)attribute_val ); MPI_Abort(MPI_COMM_WORLD, 1005 ); exit(1005); } return MPI_SUCCESS; } int test_communicators( void ) { MPI_Comm dup_comm_world, lo_comm, rev_comm, dup_comm, split_comm, world_comm; MPI_Group world_group, lo_group, rev_group; void *vvalue; int ranges[1][3]; int flag, world_rank, world_size, rank, size, n, key_1, key_3; int color, key, result; int errs = 0; MPI_Aint value; MPI_Comm_rank( MPI_COMM_WORLD, &world_rank ); MPI_Comm_size( MPI_COMM_WORLD, &world_size ); #ifdef DEBUG if (world_rank == 0) { printf( "*** Communicators ***\n" ); fflush(stdout); } #endif MPI_Comm_dup( MPI_COMM_WORLD, &dup_comm_world ); /* Exercise Comm_create by creating an equivalent to dup_comm_world (sans attributes) and a half-world communicator. */ #ifdef DEBUG if (world_rank == 0) { printf( " Comm_create\n" ); fflush(stdout); } #endif MPI_Comm_group( dup_comm_world, &world_group ); MPI_Comm_create( dup_comm_world, world_group, &world_comm ); MPI_Comm_rank( world_comm, &rank ); if (rank != world_rank) { errs++; printf( "incorrect rank in world comm: %d\n", rank ); MPI_Abort(MPI_COMM_WORLD, 3001 ); exit(3001); } n = world_size / 2; ranges[0][0] = 0; ranges[0][1] = (world_size - n) - 1; ranges[0][2] = 1; #ifdef DEBUG printf( "world rank = %d before range incl\n", world_rank );FFLUSH; #endif MPI_Group_range_incl(world_group, 1, ranges, &lo_group ); #ifdef DEBUG printf( "world rank = %d after range incl\n", world_rank );FFLUSH; #endif MPI_Comm_create(world_comm, lo_group, &lo_comm ); #ifdef DEBUG printf( "world rank = %d before group free\n", world_rank );FFLUSH; #endif MPI_Group_free( &lo_group ); #ifdef DEBUG printf( "world rank = %d after group free\n", world_rank );FFLUSH; #endif if (world_rank < (world_size - n)) { MPI_Comm_rank(lo_comm, &rank ); if (rank == MPI_UNDEFINED) { errs++; printf( "incorrect lo group rank: %d\n", rank ); fflush(stdout); MPI_Abort(MPI_COMM_WORLD, 3002 ); exit(3002); } else { /* printf( "lo in\n" );FFLUSH; */ MPI_Barrier(lo_comm ); /* printf( "lo out\n" );FFLUSH; */ } } else { if (lo_comm != MPI_COMM_NULL) { errs++; printf( "rank : %d incorrect lo comm:\n", rank ); fflush(stdout); MPI_Abort(MPI_COMM_WORLD, 3003 ); exit(3003); } } #ifdef DEBUG printf( "worldrank = %d\n", world_rank );FFLUSH; #endif MPI_Barrier(world_comm); #ifdef DEBUG printf( "bar!\n" );FFLUSH; #endif /* Check Comm_dup by adding attributes to lo_comm & duplicating */ #ifdef DEBUG if (world_rank == 0) { printf( " Comm_dup\n" ); fflush(stdout); } #endif if (lo_comm != MPI_COMM_NULL) { value = 9; MPI_Keyval_create(copy_fn, delete_fn, &key_1, &value ); value = 8; value = 7; MPI_Keyval_create(MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &key_3, &value ); /* This may generate a compilation warning; it is, however, an easy way to cache a value instead of a pointer */ /* printf( "key1 = %x key3 = %x\n", key_1, key_3 ); */ MPI_Attr_put(lo_comm, key_1, (void *) (MPI_Aint) world_rank ); MPI_Attr_put(lo_comm, key_3, (void *)0 ); MPI_Comm_dup(lo_comm, &dup_comm ); /* Note that if sizeof(int) < sizeof(void *), we can't use (void **)&value to get the value we passed into Attr_put. To avoid problems (e.g., alignment errors), we recover the value into a (void *) and cast to int. Note that this may generate warning messages from the compiler. */ MPI_Attr_get(dup_comm, key_1, (void **)&vvalue, &flag ); value = (MPI_Aint)vvalue; if (! flag) { errs++; printf( "dup_comm key_1 not found on %d\n", world_rank ); fflush( stdout ); MPI_Abort(MPI_COMM_WORLD, 3004 ); exit(3004); } if (value != world_rank) { errs++; printf( "dup_comm key_1 value incorrect: %ld, expected %d\n", (long)value, world_rank ); fflush( stdout ); MPI_Abort(MPI_COMM_WORLD, 3005 ); exit(3005); } MPI_Attr_get(dup_comm, key_3, (void **)&vvalue, &flag ); value = (MPI_Aint)vvalue; if (flag) { errs++; printf( "dup_comm key_3 found!\n" ); fflush( stdout ); MPI_Abort(MPI_COMM_WORLD, 3008 ); exit(3008); } MPI_Keyval_free(&key_1 ); MPI_Keyval_free(&key_3 ); } /* Split the world into even & odd communicators with reversed ranks. */ #ifdef DEBUG if (world_rank == 0) { printf( " Comm_split\n" ); fflush(stdout); } #endif color = world_rank % 2; key = world_size - world_rank; MPI_Comm_split(dup_comm_world, color, key, &split_comm ); MPI_Comm_size(split_comm, &size ); MPI_Comm_rank(split_comm, &rank ); if (rank != ((size - world_rank/2) - 1)) { errs++; printf( "incorrect split rank: %d\n", rank ); fflush(stdout); MPI_Abort(MPI_COMM_WORLD, 3009 ); exit(3009); } MPI_Barrier(split_comm ); /* Test each possible Comm_compare result */ #ifdef DEBUG if (world_rank == 0) { printf( " Comm_compare\n" ); fflush(stdout); } #endif MPI_Comm_compare(world_comm, world_comm, &result ); if (result != MPI_IDENT) { errs++; printf( "incorrect ident result: %d\n", result ); MPI_Abort(MPI_COMM_WORLD, 3010 ); exit(3010); } if (lo_comm != MPI_COMM_NULL) { MPI_Comm_compare(lo_comm, dup_comm, &result ); if (result != MPI_CONGRUENT) { errs++; printf( "incorrect congruent result: %d\n", result ); MPI_Abort(MPI_COMM_WORLD, 3011 ); exit(3011); } } ranges[0][0] = world_size - 1; ranges[0][1] = 0; ranges[0][2] = -1; MPI_Group_range_incl(world_group, 1, ranges, &rev_group ); MPI_Comm_create(world_comm, rev_group, &rev_comm ); MPI_Comm_compare(world_comm, rev_comm, &result ); if (result != MPI_SIMILAR && world_size != 1) { errs++; printf( "incorrect similar result: %d\n", result ); MPI_Abort(MPI_COMM_WORLD, 3012 ); exit(3012); } if (lo_comm != MPI_COMM_NULL) { MPI_Comm_compare(world_comm, lo_comm, &result ); if (result != MPI_UNEQUAL && world_size != 1) { errs++; printf( "incorrect unequal result: %d\n", result ); MPI_Abort(MPI_COMM_WORLD, 3013 ); exit(3013); } } /* Free all communicators created */ #ifdef DEBUG if (world_rank == 0) printf( " Comm_free\n" ); #endif MPI_Comm_free( &world_comm ); MPI_Comm_free( &dup_comm_world ); MPI_Comm_free( &rev_comm ); MPI_Comm_free( &split_comm ); MPI_Group_free( &world_group ); MPI_Group_free( &rev_group ); if (lo_comm != MPI_COMM_NULL) { MPI_Comm_free( &lo_comm ); MPI_Comm_free( &dup_comm ); } return errs; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/attr2type.c000644 001750 001750 00000005465 12342443660 022243 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2007 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include static int foo_keyval = MPI_KEYVAL_INVALID; int foo_initialize(void); void foo_finalize(void); int foo_copy_attr_function(MPI_Datatype type, int type_keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag); int foo_delete_attr_function(MPI_Datatype type, int type_keyval, void *attribute_val, void *extra_state); static const char *my_func = 0; static int verbose = 0; static int delete_called = 0; static int copy_called = 0; int main(int argc, char *argv[]) { int mpi_errno; MPI_Datatype type, duptype; int rank; MPI_Init(&argc, &argv); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); foo_initialize(); mpi_errno = MPI_Type_contiguous(2, MPI_INT, &type); mpi_errno = MPI_Type_set_attr(type, foo_keyval, NULL); mpi_errno = MPI_Type_dup(type, &duptype); my_func = "Free of type"; mpi_errno = MPI_Type_free(&type); my_func = "free of duptype"; mpi_errno = MPI_Type_free(&duptype); foo_finalize(); if (rank == 0) { int errs = 0; if (copy_called != 1) { printf( "Copy called %d times; expected once\n", copy_called ); errs++; } if (delete_called != 2) { printf( "Delete called %d times; expected twice\n", delete_called ); errs++; } if (errs == 0) { printf( " No Errors\n" ); }else if(mpi_errno!=MPI_SUCCESS){ printf( " Output fail - Found %d errors\n", errs ); }else { printf( " Found %d errors\n", errs ); } fflush(stdout); } MPI_Finalize(); return 0; } int foo_copy_attr_function(MPI_Datatype type, int type_keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag) { if (verbose) printf("copy fn. called\n"); copy_called ++; * (char **) attribute_val_out = NULL; *flag = 1; return MPI_SUCCESS; } int foo_delete_attr_function(MPI_Datatype type, int type_keyval, void *attribute_val, void *extra_state) { if (verbose) printf("delete fn. called in %s\n", my_func ); delete_called ++; return MPI_SUCCESS; } int foo_initialize(void) { int mpi_errno; /* create keyval for use later */ mpi_errno = MPI_Type_create_keyval(foo_copy_attr_function, foo_delete_attr_function, &foo_keyval, NULL); if (mpi_errno==MPI_SUCCESS && verbose) printf("created keyval\n"); return 0; } void foo_finalize(void) { int mpi_errno; /* remove keyval */ mpi_errno = MPI_Type_free_keyval(&foo_keyval); if (mpi_errno==MPI_SUCCESS && verbose) printf("freed keyval\n"); return; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/fkeyval.c000644 001750 001750 00000006311 12342443661 021736 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" /* static char MTestDescrip[] = "Test freeing keyvals while still attached to \ a communicator, then make sure that the keyval delete and copy code are still \ executed"; */ /* Function prototypes to keep compilers happy */ int copy_fn( MPI_Comm oldcomm, int keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag); int delete_fn( MPI_Comm comm, int keyval, void *attribute_val, void *extra_state); /* Copy increments the attribute value */ int copy_fn( MPI_Comm oldcomm, int keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag) { /* Copy the address of the attribute */ *(void **)attribute_val_out = attribute_val_in; /* Change the value */ *(int *)attribute_val_in = *(int *)attribute_val_in + 1; /* set flag to 1 to tell comm dup to insert this attribute into the new communicator */ *flag = 1; return MPI_SUCCESS; } /* Delete decrements the attribute value */ int delete_fn( MPI_Comm comm, int keyval, void *attribute_val, void *extra_state) { *(int *)attribute_val = *(int *)attribute_val - 1; return MPI_SUCCESS; } int main( int argc, char *argv[] ) { int errs = 0; int attrval; int i, key[32], keyval, saveKeyval; MPI_Comm comm, dupcomm; MTest_Init( &argc, &argv ); while (MTestGetIntracomm( &comm, 1 )) { if (comm == MPI_COMM_NULL) continue; MPI_Keyval_create( copy_fn, delete_fn, &keyval, (void *)0 ); saveKeyval = keyval; /* in case we need to free explicitly */ attrval = 1; MPI_Attr_put( comm, keyval, (void*)&attrval ); /* See MPI-1, 5.7.1. Freeing the keyval does not remove it if it is in use in an attribute */ MPI_Keyval_free( &keyval ); /* We create some dummy keyvals here in case the same keyval is reused */ for (i=0; i<32; i++) { MPI_Keyval_create( MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &key[i], (void *)0 ); } MPI_Comm_dup( comm, &dupcomm ); /* Check that the attribute was copied */ if (attrval != 2) { errs++; printf( "Attribute not incremented when comm dup'ed (%s)\n", MTestGetIntracommName() ); } MPI_Comm_free( &dupcomm ); if (attrval != 1) { errs++; printf( "Attribute not decremented when dupcomm %s freed\n", MTestGetIntracommName() ); } /* Check that the attribute was freed in the dupcomm */ if (comm != MPI_COMM_WORLD && comm != MPI_COMM_SELF) { MPI_Comm_free( &comm ); /* Check that the original attribute was freed */ if (attrval != 0) { errs++; printf( "Attribute not decremented when comm %s freed\n", MTestGetIntracommName() ); } } else { /* Explicitly delete the attributes from world and self */ MPI_Attr_delete( comm, saveKeyval ); } /* Free those other keyvals */ for (i=0; i<32; i++) { MPI_Keyval_free( &key[i] ); } } MTest_Finalize( errs ); MPI_Finalize(); /* The attributes on comm self and world were deleted by finalize (see separate test) */ return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/attrordertype.c000644 001750 001750 00000005574 12342443661 023217 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" /* static char MTestDescrip[] = "Test creating and inserting attributes in \ different orders to ensure that the list management code handles all cases."; */ int checkAttrs( MPI_Datatype type, int n, int key[], int attrval[] ); int checkNoAttrs( MPI_Datatype type, int n, int key[] ); int main( int argc, char *argv[] ) { int errs = 0; int key[3], attrval[3]; int i; MPI_Datatype type; MTest_Init( &argc, &argv ); { type = MPI_INT; /* Create key values */ for (i=0; i<3; i++) { MPI_Type_create_keyval( MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &key[i], (void *)0 ); attrval[i] = 1024 * i; } /* Insert attribute in several orders. Test after put with get, then delete, then confirm delete with get. */ MPI_Type_set_attr( type, key[2], &attrval[2] ); MPI_Type_set_attr( type, key[1], &attrval[1] ); MPI_Type_set_attr( type, key[0], &attrval[0] ); errs += checkAttrs( type, 3, key, attrval ); MPI_Type_delete_attr( type, key[0] ); MPI_Type_delete_attr( type, key[1] ); MPI_Type_delete_attr( type, key[2] ); errs += checkNoAttrs( type, 3, key ); MPI_Type_set_attr( type, key[1], &attrval[1] ); MPI_Type_set_attr( type, key[2], &attrval[2] ); MPI_Type_set_attr( type, key[0], &attrval[0] ); errs += checkAttrs( type, 3, key, attrval ); MPI_Type_delete_attr( type, key[2] ); MPI_Type_delete_attr( type, key[1] ); MPI_Type_delete_attr( type, key[0] ); errs += checkNoAttrs( type, 3, key ); MPI_Type_set_attr( type, key[0], &attrval[0] ); MPI_Type_set_attr( type, key[1], &attrval[1] ); MPI_Type_set_attr( type, key[2], &attrval[2] ); errs += checkAttrs( type, 3, key, attrval ); MPI_Type_delete_attr( type, key[1] ); MPI_Type_delete_attr( type, key[2] ); MPI_Type_delete_attr( type, key[0] ); errs += checkNoAttrs( type, 3, key ); for (i=0; i<3; i++) { MPI_Type_free_keyval( &key[i] ); } } MTest_Finalize( errs ); MPI_Finalize(); return 0; } int checkAttrs( MPI_Datatype type, int n, int key[], int attrval[] ) { int errs = 0; int i, flag, *val_p; for (i=0; i #include "mpitest.h" /* static char MTestDescrip[] = "Test freeing keyvals while still attached to \ a communicator, then make sure that the keyval delete and copy code are still \ executed"; */ /* Function prototypes to keep compilers happy */ int copy_fn( MPI_Comm oldcomm, int keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag); int delete_fn( MPI_Comm comm, int keyval, void *attribute_val, void *extra_state); /* Copy increments the attribute value */ int copy_fn( MPI_Comm oldcomm, int keyval, void *extra_state, void *attribute_val_in, void *attribute_val_out, int *flag) { /* Copy the address of the attribute */ *(void **)attribute_val_out = attribute_val_in; /* Change the value */ *(int *)attribute_val_in = *(int *)attribute_val_in + 1; /* set flag to 1 to tell comm dup to insert this attribute into the new communicator */ *flag = 1; return MPI_SUCCESS; } /* Delete decrements the attribute value */ int delete_fn( MPI_Comm comm, int keyval, void *attribute_val, void *extra_state) { *(int *)attribute_val = *(int *)attribute_val - 1; return MPI_SUCCESS; } int main( int argc, char *argv[] ) { int errs = 0; int attrval; int i, key[32], keyval, saveKeyval; MPI_Comm comm, dupcomm; MTest_Init( &argc, &argv ); while (MTestGetIntracomm( &comm, 1 )) { if (comm == MPI_COMM_NULL) continue; MPI_Comm_create_keyval( copy_fn, delete_fn, &keyval, (void *)0 ); saveKeyval = keyval; /* in case we need to free explicitly */ attrval = 1; MPI_Comm_set_attr( comm, keyval, (void*)&attrval ); /* See MPI-1, 5.7.1. Freeing the keyval does not remove it if it is in use in an attribute */ MPI_Comm_free_keyval( &keyval ); /* We create some dummy keyvals here in case the same keyval is reused */ for (i=0; i<32; i++) { MPI_Comm_create_keyval( MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &key[i], (void *)0 ); } MPI_Comm_dup( comm, &dupcomm ); /* Check that the attribute was copied */ if (attrval != 2) { errs++; printf( "Attribute not incremented when comm dup'ed (%s)\n", MTestGetIntracommName() ); } MPI_Comm_free( &dupcomm ); if (attrval != 1) { errs++; printf( "Attribute not decremented when dupcomm %s freed\n", MTestGetIntracommName() ); } /* Check that the attribute was freed in the dupcomm */ if (comm != MPI_COMM_WORLD && comm != MPI_COMM_SELF) { MPI_Comm_free( &comm ); /* Check that the original attribute was freed */ if (attrval != 0) { errs++; printf( "Attribute not decremented when comm %s freed\n", MTestGetIntracommName() ); } } else { /* Explicitly delete the attributes from world and self */ MPI_Comm_delete_attr( comm, saveKeyval ); } /* Free those other keyvals */ for (i=0; i<32; i++) { MPI_Comm_free_keyval( &key[i] ); } } MTest_Finalize( errs ); MPI_Finalize(); /* The attributes on comm self and world were deleted by finalize (see separate test) */ return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/attr/CMakeLists.txt000644 001750 001750 00000006161 12342443654 022676 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include/") # add_executable(attr2type attr2type.c) add_executable(attrend2 attrend2.c) # add_executable(attrend attrend.c) # add_executable(attrerr attrerr.c) # add_executable(attrerrcomm attrerrcomm.c) # add_executable(attrerrtype attrerrtype.c) # add_executable(attric attric.c) # add_executable(attrorder attrorder.c) # add_executable(attrordercomm attrordercomm.c) # add_executable(attrordertype attrordertype.c) # add_executable(attrt attrt.c) # add_executable(baseattr2 baseattr2.c) # add_executable(baseattrcomm baseattrcomm.c) # add_executable(fkeyval fkeyval.c) # add_executable(fkeyvalcomm fkeyvalcomm.c) # add_executable(fkeyvaltype fkeyvaltype.c) # add_executable(keyval_double_free keyval_double_free.c) # target_link_libraries(attr2type simgrid mtest_c) target_link_libraries(attrend2 simgrid mtest_c) # target_link_libraries(attrend simgrid mtest_c) # target_link_libraries(attrerr simgrid mtest_c) # target_link_libraries(attrerrcomm simgrid mtest_c) # target_link_libraries(attrerrtype simgrid mtest_c) # target_link_libraries(attric simgrid mtest_c) # target_link_libraries(attrorder simgrid mtest_c) # target_link_libraries(attrordercomm simgrid mtest_c) # target_link_libraries(attrordertype simgrid mtest_c) # target_link_libraries(attrt simgrid mtest_c) # target_link_libraries(baseattr2 simgrid mtest_c) # target_link_libraries(baseattrcomm simgrid mtest_c) # target_link_libraries(fkeyval simgrid mtest_c) # target_link_libraries(fkeyvalcomm simgrid mtest_c) # target_link_libraries(fkeyvaltype simgrid mtest_c) # target_link_libraries(keyval_double_free simgrid mtest_c) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/attr2type.c ${CMAKE_CURRENT_SOURCE_DIR}/attrend2.c ${CMAKE_CURRENT_SOURCE_DIR}/attrend.c ${CMAKE_CURRENT_SOURCE_DIR}/attrerr.c ${CMAKE_CURRENT_SOURCE_DIR}/attrerrcomm.c ${CMAKE_CURRENT_SOURCE_DIR}/attrerrtype.c ${CMAKE_CURRENT_SOURCE_DIR}/attric.c ${CMAKE_CURRENT_SOURCE_DIR}/attrorder.c ${CMAKE_CURRENT_SOURCE_DIR}/attrordercomm.c ${CMAKE_CURRENT_SOURCE_DIR}/attrordertype.c ${CMAKE_CURRENT_SOURCE_DIR}/attrt.c ${CMAKE_CURRENT_SOURCE_DIR}/baseattr2.c ${CMAKE_CURRENT_SOURCE_DIR}/baseattrcomm.c ${CMAKE_CURRENT_SOURCE_DIR}/fkeyval.c ${CMAKE_CURRENT_SOURCE_DIR}/fkeyvalcomm.c ${CMAKE_CURRENT_SOURCE_DIR}/fkeyvaltype.c ${CMAKE_CURRENT_SOURCE_DIR}/keyval_double_free.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/000755 001750 001750 00000000000 12342443666 020144 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/cartshift1.c000644 001750 001750 00000005104 12342443662 022354 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" int main( int argc, char *argv[] ) { int errs = 0; int size, rank; int source, dest; int dims[2], periods[2]; MPI_Comm comm; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); dims[0] = size; periods[0] = 1; MPI_Cart_create( MPI_COMM_WORLD, 1, dims, periods, 0, &comm ); MPI_Cart_shift( comm, 0, 1, &source, &dest ); if (source != ((rank - 1 + size) % size)) { errs++; printf( "source for shift 1 is %d\n", source ); } if (dest != ((rank + 1) % size)) { errs++; printf( "dest for shift 1 is %d\n", dest ); } MPI_Cart_shift( comm, 0, 0, &source, &dest ); if (source != rank) { errs++; printf( "Source for shift 0 is %d\n", source ); } if (dest != rank) { errs++; printf( "Dest for shift 0 is %d\n", dest ); } MPI_Cart_shift( comm, 0, -1, &source, &dest ); if (source != ((rank + 1) % size)) { errs++; printf( "source for shift -1 is %d\n", source ); } if (dest != ((rank - 1 + size) % size)) { errs++; printf( "dest for shift -1 is %d\n", dest ); } /* Now, with non-periodic */ MPI_Comm_free( &comm ); periods[0] = 0; MPI_Cart_create( MPI_COMM_WORLD, 1, dims, periods, 0, &comm ); MPI_Cart_shift( comm, 0, 1, &source, &dest ); if ((rank > 0 && source != (rank - 1)) || (rank == 0 && source != MPI_PROC_NULL)) { errs++; printf( "source for non-periodic shift 1 is %d\n", source ); } if ((rank < size-1 && dest != rank + 1) || ((rank == size-1) && dest != MPI_PROC_NULL)) { errs++; printf( "dest for non-periodic shift 1 is %d\n", dest ); } MPI_Cart_shift( comm, 0, 0, &source, &dest ); if (source != rank) { errs++; printf( "Source for non-periodic shift 0 is %d\n", source ); } if (dest != rank) { errs++; printf( "Dest for non-periodic shift 0 is %d\n", dest ); } MPI_Cart_shift( comm, 0, -1, &source, &dest ); if ((rank < size - 1 && source != rank + 1) || (rank == size - 1 && source != MPI_PROC_NULL)) { errs++; printf( "source for non-periodic shift -1 is %d\n", source ); } if ((rank > 0 && dest != rank - 1) || (rank == 0 && dest != MPI_PROC_NULL)) { errs++; printf( "dest for non-periodic shift -1 is %d\n", dest ); } MPI_Comm_free( &comm ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/testlist000644 001750 001750 00000000716 12342443666 021746 0ustar00cici000000 000000 #need Cart implem #cartmap1 4 cartzero 4 cartshift1 4 cartsuball 4 cartcreates 4 #need MPI_Dims_create #dims1 4 #dims2 1 #need MPI_Error_class, MPI_Comm_remote_size, MPI_Graph_map #graphmap1 4 #need MPI_Topo_test, MPI_Cart_create #topotest 4 #need MPI_Cart_create, MPI_Cart_get, MPI_Comm_remote_size, MPI_Dims_create ... #topodup 4 #need MPI_Graph* #graphcr 4 #graphcr2 4 #distgraph1 4 mpiversion=2.2 #dgraph_unwgt 4 mpiversion=2.2 #neighb_coll 4 mpiversion=3.0 SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/graphcr.c000644 001750 001750 00000001526 12342443662 021736 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Create a communicator with a graph that contains no processes"; */ int main( int argc, char *argv[] ) { int errs = 0; int *index = 0, *edges = 0; MPI_Comm comm; MTest_Init( &argc, &argv ); /* MPI 2.1, page 246, lines 29-30 make it clear that this is a valid (not erroneous) call that must return MPI_COMM_NULL */ MPI_Graph_create( MPI_COMM_WORLD, 0, index, edges, 0, &comm ); if (comm != MPI_COMM_NULL) { errs++; fprintf( stderr, "Expected MPI_COMM_NULL from empty graph create\n" ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/topodup.c000644 001750 001750 00000006571 12342443662 022007 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" int main( int argc, char *argv[] ) { int errs = 0, i, k; int dims[2], periods[2], wsize; int outdims[2], outperiods[2], outcoords[2]; int topo_type; int *index, *edges, *outindex, *outedges; MPI_Comm comm1, comm2; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &wsize ); /* Create a cartesian topology, get its characteristics, then dup it and check that the new communicator has the same properties */ dims[0] = dims[1] = 0; MPI_Dims_create( wsize, 2, dims ); periods[0] = periods[1] = 0; MPI_Cart_create( MPI_COMM_WORLD, 2, dims, periods, 0, &comm1 ); MPI_Comm_dup( comm1, &comm2 ); MPI_Topo_test( comm2, &topo_type ); if (topo_type != MPI_CART) { errs++; printf( "Topo type of duped cart was not cart\n" ); } else { MPI_Cart_get( comm2, 2, outdims, outperiods, outcoords ); for (i=0; i<2; i++) { if (outdims[i] != dims[i]) { errs++; printf( "%d = outdims[%d] != dims[%d] = %d\n", outdims[i], i, i, dims[i] ); } if (outperiods[i] != periods[i]) { errs++; printf( "%d = outperiods[%d] != periods[%d] = %d\n", outperiods[i], i, i, periods[i] ); } } } MPI_Comm_free( &comm2 ); MPI_Comm_free( &comm1 ); /* Now do the same with a graph topology */ if (wsize >= 3) { index = (int*)malloc(wsize * sizeof(int) ); edges = (int*)malloc(wsize * 2 * sizeof(int) ); if (!index || !edges) { printf( "Unable to allocate %d words for index or edges\n", 3 * wsize ); MPI_Abort( MPI_COMM_WORLD, 1 ); } index[0] = 2; for (i=1; i #include "mpitest.h" int main( int argc, char *argv[] ) { int errs = 0; int topo_type, size, dims[1], periods[1]; MPI_Comm comm; MTest_Init( &argc, &argv ); /* Check that topo test returns the correct type, including MPI_UNDEFINED */ MPI_Topo_test( MPI_COMM_WORLD, &topo_type ); if (topo_type != MPI_UNDEFINED) { errs++; printf( "Topo type of comm world is not UNDEFINED\n" ); } MPI_Comm_size( MPI_COMM_WORLD, &size ); dims[0] = size; periods[0] = 0; MPI_Cart_create( MPI_COMM_WORLD, 1, dims, periods, 0, &comm ); MPI_Topo_test( comm, &topo_type ); if (topo_type != MPI_CART) { errs++; printf( "Topo type of cart comm is not CART\n" ); } MPI_Comm_free( &comm ); /* FIXME: still need graph example */ MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/distgraph1.c000644 001750 001750 00000051441 12342443662 022357 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include #include #include "mpitest.h" #define NUM_GRAPHS 10 #define MAX_WEIGHT 100 /* convenience globals */ int size, rank; /* We need MPI 2.2 to be able to compile the following routines. */ #if MTEST_HAVE_MIN_MPI_VERSION(2,2) /* Maybe use a bit vector instead? */ int **layout; #define MAX_LAYOUT_NAME_LEN 256 char graph_layout_name[MAX_LAYOUT_NAME_LEN] = {'\0'}; static void create_graph_layout(int graph_num) { int i, j; if (rank == 0) { switch (graph_num) { case 0: strncpy(graph_layout_name, "deterministic complete graph", MAX_LAYOUT_NAME_LEN); for (i = 0; i < size; i++) for (j = 0; j < size; j++) layout[i][j] = (i + 2) * (j + 1); break; case 1: strncpy(graph_layout_name, "every other edge deleted", MAX_LAYOUT_NAME_LEN); for (i = 0; i < size; i++) for (j = 0; j < size; j++) layout[i][j] = (j % 2 ? (i + 2) * (j + 1) : 0); break; case 2: strncpy(graph_layout_name, "only self-edges", MAX_LAYOUT_NAME_LEN); for (i = 0; i < size; i++) { for (j = 0; j < size; j++) { if (i == rank && j == rank) layout[i][j] = 10 * (i + 1); else layout[i][j] = 0; } } break; case 3: strncpy(graph_layout_name, "no edges", MAX_LAYOUT_NAME_LEN); for (i = 0; i < size; i++) for (j = 0; j < size; j++) layout[i][j] = 0; break; default: strncpy(graph_layout_name, "a random incomplete graph", MAX_LAYOUT_NAME_LEN); srand(graph_num); /* Create a connectivity graph; layout[i,j]==w represents an outward * connectivity from i to j with weight w, w==0 is no edge. */ for (i = 0; i < size; i++) { for (j = 0; j < size; j++) { /* disable about a third of the edges */ if (((rand() * 1.0) / RAND_MAX) < 0.33) layout[i][j] = 0; else layout[i][j] = rand() % MAX_WEIGHT; } } break; } } /* because of the randomization we must determine the graph on rank 0 and * send the layout to all other processes */ MPI_Bcast(graph_layout_name, MAX_LAYOUT_NAME_LEN, MPI_CHAR, 0, MPI_COMM_WORLD); for (i = 0; i < size; ++i) { MPI_Bcast(layout[i], size, MPI_INT, 0, MPI_COMM_WORLD); } } static int verify_comm(MPI_Comm comm) { int local_errs = 0; int i, j; int indegree, outdegree, weighted; int *sources, *sweights, *destinations, *dweights; int use_dup; int topo_type = MPI_UNDEFINED; MPI_Comm dupcomm = MPI_COMM_NULL; sources = (int *) malloc(size * sizeof(int)); sweights = (int *) malloc(size * sizeof(int)); destinations = (int *) malloc(size * sizeof(int)); dweights = (int *) malloc(size * sizeof(int)); for (use_dup = 0; use_dup <= 1; ++use_dup) { if (!use_dup) { MPI_Dist_graph_neighbors_count(comm, &indegree, &outdegree, &weighted); } else { MPI_Comm_dup(comm, &dupcomm); comm = dupcomm; /* caller retains original comm value */ } MPI_Topo_test(comm, &topo_type); if (topo_type != MPI_DIST_GRAPH) { fprintf(stderr, "topo_type != MPI_DIST_GRAPH\n"); ++local_errs; } j = 0; for (i = 0; i < size; i++) if (layout[i][rank]) j++; if (j != indegree) { fprintf(stderr, "indegree does not match, expected=%d got=%d, layout='%s'\n", indegree, j, graph_layout_name); ++local_errs; } j = 0; for (i = 0; i < size; i++) if (layout[rank][i]) j++; if (j != outdegree) { fprintf(stderr, "outdegree does not match, expected=%d got=%d, layout='%s'\n", outdegree, j, graph_layout_name); ++local_errs; } if ((indegree || outdegree) && (weighted == 0)) { fprintf(stderr, "MPI_Dist_graph_neighbors_count thinks the graph is not weighted\n"); ++local_errs; } MPI_Dist_graph_neighbors(comm, indegree, sources, sweights, outdegree, destinations, dweights); /* For each incoming and outgoing edge in the matrix, search if * the query function listed it in the sources. */ for (i = 0; i < size; i++) { if (layout[i][rank]) { for (j = 0; j < indegree; j++) { assert(sources[j] >= 0); assert(sources[j] < size); if (sources[j] == i) break; } if (j == indegree) { fprintf(stderr, "no edge from %d to %d specified\n", i, rank); ++local_errs; } else { if (sweights[j] != layout[i][rank]) { fprintf(stderr, "incorrect weight for edge (%d,%d): %d instead of %d\n", i, rank, sweights[j], layout[i][rank]); ++local_errs; } } } if (layout[rank][i]) { for (j = 0; j < outdegree; j++) { assert(destinations[j] >= 0); assert(destinations[j] < size); if (destinations[j] == i) break; } if (j == outdegree) { fprintf(stderr, "no edge from %d to %d specified\n", rank, i); ++local_errs; } else { if (dweights[j] != layout[rank][i]) { fprintf(stderr, "incorrect weight for edge (%d,%d): %d instead of %d\n", rank, i, dweights[j], layout[rank][i]); ++local_errs; } } } } /* For each incoming and outgoing edge in the sources, we should * have an entry in the matrix */ for (i = 0; i < indegree; i++) { if (layout[sources[i]][rank] != sweights[i]) { fprintf(stderr, "edge (%d,%d) has a weight %d instead of %d\n", i, rank, sweights[i], layout[sources[i]][rank]); ++local_errs; } } for (i = 0; i < outdegree; i++) { if (layout[rank][destinations[i]] != dweights[i]) { fprintf(stderr, "edge (%d,%d) has a weight %d instead of %d\n", rank, i, dweights[i], layout[rank][destinations[i]]); ++local_errs; } } } if (dupcomm != MPI_COMM_NULL) MPI_Comm_free(&dupcomm); return local_errs; } #endif /* At least MPI 2.2 */ int main(int argc, char *argv[]) { int errs = 0; int i, j, k, p; int indegree, outdegree, reorder; int check_indegree, check_outdegree, check_weighted; int *sources, *sweights, *destinations, *dweights, *degrees; MPI_Comm comm; MTest_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); #if MTEST_HAVE_MIN_MPI_VERSION(2,2) layout = (int **) malloc(size * sizeof(int *)); assert(layout); for (i = 0; i < size; i++) { layout[i] = (int *) malloc(size * sizeof(int)); assert(layout[i]); } /* alloc size*size ints to handle the all-on-one-process case */ sources = (int *) malloc(size * size * sizeof(int)); sweights = (int *) malloc(size * size * sizeof(int)); destinations = (int *) malloc(size * size * sizeof(int)); dweights = (int *) malloc(size * size * sizeof(int)); degrees = (int *) malloc(size * size * sizeof(int)); for (i = 0; i < NUM_GRAPHS; i++) { create_graph_layout(i); if (rank == 0) { MTestPrintfMsg( 1, "using graph layout '%s'\n", graph_layout_name ); } /* MPI_Dist_graph_create_adjacent */ if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create_adjacent\n" ); } indegree = 0; k = 0; for (j = 0; j < size; j++) { if (layout[j][rank]) { indegree++; sources[k] = j; sweights[k++] = layout[j][rank]; } } outdegree = 0; k = 0; for (j = 0; j < size; j++) { if (layout[rank][j]) { outdegree++; destinations[k] = j; dweights[k++] = layout[rank][j]; } } for (reorder = 0; reorder <= 1; reorder++) { MPI_Dist_graph_create_adjacent(MPI_COMM_WORLD, indegree, sources, sweights, outdegree, destinations, dweights, MPI_INFO_NULL, reorder, &comm); MPI_Barrier(comm); errs += verify_comm(comm); MPI_Comm_free(&comm); } /* a weak check that passing MPI_UNWEIGHTED doesn't cause * create_adjacent to explode */ MPI_Dist_graph_create_adjacent(MPI_COMM_WORLD, indegree, sources, MPI_UNWEIGHTED, outdegree, destinations, MPI_UNWEIGHTED, MPI_INFO_NULL, reorder, &comm); MPI_Barrier(comm); /* intentionally no verify here, weights won't match */ MPI_Comm_free(&comm); /* MPI_Dist_graph_create() where each process specifies its * outgoing edges */ if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create w/ outgoing only\n" ); } sources[0] = rank; k = 0; for (j = 0; j < size; j++) { if (layout[rank][j]) { destinations[k] = j; dweights[k++] = layout[rank][j]; } } degrees[0] = k; for (reorder = 0; reorder <= 1; reorder++) { MPI_Dist_graph_create(MPI_COMM_WORLD, 1, sources, degrees, destinations, dweights, MPI_INFO_NULL, reorder, &comm); MPI_Barrier(comm); errs += verify_comm(comm); MPI_Comm_free(&comm); } /* MPI_Dist_graph_create() where each process specifies its * incoming edges */ if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create w/ incoming only\n" ); } k = 0; for (j = 0; j < size; j++) { if (layout[j][rank]) { sources[k] = j; sweights[k] = layout[j][rank]; degrees[k] = 1; destinations[k++] = rank; } } for (reorder = 0; reorder <= 1; reorder++) { MPI_Dist_graph_create(MPI_COMM_WORLD, k, sources, degrees, destinations, sweights, MPI_INFO_NULL, reorder, &comm); MPI_Barrier(comm); errs += verify_comm(comm); MPI_Comm_free(&comm); } /* MPI_Dist_graph_create() where rank 0 specifies the entire * graph */ if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create w/ rank 0 specifies only\n" ); } p = 0; for (j = 0; j < size; j++) { for (k = 0; k < size; k++) { if (layout[j][k]) { sources[p] = j; sweights[p] = layout[j][k]; degrees[p] = 1; destinations[p++] = k; } } } for (reorder = 0; reorder <= 1; reorder++) { MPI_Dist_graph_create(MPI_COMM_WORLD, (rank == 0) ? p : 0, sources, degrees, destinations, sweights, MPI_INFO_NULL, reorder, &comm); MPI_Barrier(comm); errs += verify_comm(comm); MPI_Comm_free(&comm); } /* MPI_Dist_graph_create() where rank 0 specifies the entire * graph and all other ranks pass NULL. Can catch implementation * problems when MPI_UNWEIGHTED==NULL. */ if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create w/ rank 0 specifies only -- NULLs\n"); } p = 0; for (j = 0; j < size; j++) { for (k = 0; k < size; k++) { if (layout[j][k]) { sources[p] = j; sweights[p] = layout[j][k]; degrees[p] = 1; destinations[p++] = k; } } } for (reorder = 0; reorder <= 1; reorder++) { if (rank == 0) { MPI_Dist_graph_create(MPI_COMM_WORLD, p, sources, degrees, destinations, sweights, MPI_INFO_NULL, reorder, &comm); } else { MPI_Dist_graph_create(MPI_COMM_WORLD, 0, NULL, NULL, NULL, NULL, MPI_INFO_NULL, reorder, &comm); } MPI_Barrier(comm); errs += verify_comm(comm); MPI_Comm_free(&comm); } } /* now tests that don't depend on the layout[][] array */ /* The MPI-2.2 standard recommends implementations set * MPI_UNWEIGHTED==NULL, but this leads to an ambiguity. The draft * MPI-3.0 standard specifically recommends _not_ setting it equal * to NULL. */ if (MPI_UNWEIGHTED == NULL) { fprintf(stderr, "MPI_UNWEIGHTED should not be NULL\n"); ++errs; } /* MPI_Dist_graph_create() with no graph */ if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create w/ no graph\n" ); } for (reorder = 0; reorder <= 1; reorder++) { MPI_Dist_graph_create(MPI_COMM_WORLD, 0, sources, degrees, destinations, sweights, MPI_INFO_NULL, reorder, &comm); MPI_Dist_graph_neighbors_count(comm, &check_indegree, &check_outdegree, &check_weighted); if (!check_weighted) { fprintf(stderr, "expected weighted == TRUE for the \"no graph\" case\n"); ++errs; } MPI_Comm_free(&comm); } /* MPI_Dist_graph_create() with no graph -- passing MPI_WEIGHTS_EMPTY instead */ /* NOTE that MPI_WEIGHTS_EMPTY was added in MPI-3 and does not appear before then. This part of the test thus requires a check on the MPI major version */ #if MPI_VERSION >= 3 if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create w/ no graph\n" ); } for (reorder = 0; reorder <= 1; reorder++) { MPI_Dist_graph_create(MPI_COMM_WORLD, 0, sources, degrees, destinations, MPI_WEIGHTS_EMPTY, MPI_INFO_NULL, reorder, &comm); MPI_Dist_graph_neighbors_count(comm, &check_indegree, &check_outdegree, &check_weighted); if (!check_weighted) { fprintf(stderr, "expected weighted == TRUE for the \"no graph -- MPI_WEIGHTS_EMPTY\" case\n"); ++errs; } MPI_Comm_free(&comm); } #endif /* MPI_Dist_graph_create() with no graph -- passing NULLs instead */ if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create w/ no graph -- NULLs\n" ); } for (reorder = 0; reorder <= 1; reorder++) { MPI_Dist_graph_create(MPI_COMM_WORLD, 0, NULL, NULL, NULL, NULL, MPI_INFO_NULL, reorder, &comm); MPI_Dist_graph_neighbors_count(comm, &check_indegree, &check_outdegree, &check_weighted); /* ambiguous if they are equal, only check when they are distinct values. */ if (MPI_UNWEIGHTED != NULL) { if (!check_weighted) { fprintf(stderr, "expected weighted == TRUE for the \"no graph -- NULLs\" case\n"); ++errs; } } MPI_Comm_free(&comm); } /* MPI_Dist_graph_create() with no graph -- passing NULLs+MPI_UNWEIGHTED instead */ if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create w/ no graph -- NULLs+MPI_UNWEIGHTED\n" ); } for (reorder = 0; reorder <= 1; reorder++) { MPI_Dist_graph_create(MPI_COMM_WORLD, 0, NULL, NULL, NULL, MPI_UNWEIGHTED, MPI_INFO_NULL, reorder, &comm); MPI_Dist_graph_neighbors_count(comm, &check_indegree, &check_outdegree, &check_weighted); /* ambiguous if they are equal, only check when they are distinct values. */ if (MPI_UNWEIGHTED != NULL) { if (check_weighted) { fprintf(stderr, "expected weighted == FALSE for the \"no graph -- NULLs+MPI_UNWEIGHTED\" case\n"); ++errs; } } MPI_Comm_free(&comm); } /* MPI_Dist_graph_create_adjacent() with no graph */ if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create_adjacent w/ no graph\n" ); } for (reorder = 0; reorder <= 1; reorder++) { MPI_Dist_graph_create_adjacent(MPI_COMM_WORLD, 0, sources, sweights, 0, destinations, dweights, MPI_INFO_NULL, reorder, &comm); MPI_Dist_graph_neighbors_count(comm, &check_indegree, &check_outdegree, &check_weighted); if (!check_weighted) { fprintf(stderr, "expected weighted == TRUE for the \"no graph\" case\n"); ++errs; } MPI_Comm_free(&comm); } /* MPI_Dist_graph_create_adjacent() with no graph -- passing MPI_WEIGHTS_EMPTY instead */ /* NOTE that MPI_WEIGHTS_EMPTY was added in MPI-3 and does not appear before then. This part of the test thus requires a check on the MPI major version */ #if MPI_VERSION >= 3 if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create_adjacent w/ no graph -- MPI_WEIGHTS_EMPTY\n" ); } for (reorder = 0; reorder <= 1; reorder++) { MPI_Dist_graph_create_adjacent(MPI_COMM_WORLD, 0, sources, MPI_WEIGHTS_EMPTY, 0, destinations, MPI_WEIGHTS_EMPTY, MPI_INFO_NULL, reorder, &comm); MPI_Dist_graph_neighbors_count(comm, &check_indegree, &check_outdegree, &check_weighted); if (!check_weighted) { fprintf(stderr, "expected weighted == TRUE for the \"no graph -- MPI_WEIGHTS_EMPTY\" case\n"); ++errs; } MPI_Comm_free(&comm); } #endif /* MPI_Dist_graph_create_adjacent() with no graph -- passing NULLs instead */ if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create_adjacent w/ no graph -- NULLs\n" ); } for (reorder = 0; reorder <= 1; reorder++) { MPI_Dist_graph_create_adjacent(MPI_COMM_WORLD, 0, NULL, NULL, 0, NULL, NULL, MPI_INFO_NULL, reorder, &comm); MPI_Dist_graph_neighbors_count(comm, &check_indegree, &check_outdegree, &check_weighted); /* ambiguous if they are equal, only check when they are distinct values. */ if (MPI_UNWEIGHTED != NULL) { if (!check_weighted) { fprintf(stderr, "expected weighted == TRUE for the \"no graph -- NULLs\" case\n"); ++errs; } } MPI_Comm_free(&comm); } /* MPI_Dist_graph_create_adjacent() with no graph -- passing NULLs+MPI_UNWEIGHTED instead */ if (rank == 0) { MTestPrintfMsg( 1, "testing MPI_Dist_graph_create_adjacent w/ no graph -- NULLs+MPI_UNWEIGHTED\n"); } for (reorder = 0; reorder <= 1; reorder++) { MPI_Dist_graph_create_adjacent(MPI_COMM_WORLD, 0, NULL, MPI_UNWEIGHTED, 0, NULL, MPI_UNWEIGHTED, MPI_INFO_NULL, reorder, &comm); MPI_Dist_graph_neighbors_count(comm, &check_indegree, &check_outdegree, &check_weighted); /* ambiguous if they are equal, only check when they are distinct values. */ if (MPI_UNWEIGHTED != NULL) { if (check_weighted) { fprintf(stderr, "expected weighted == FALSE for the \"no graph -- NULLs+MPI_UNWEIGHTED\" case\n"); ++errs; } } MPI_Comm_free(&comm); } for (i = 0; i < size; i++) free(layout[i]); free(layout); #endif MTest_Finalize(errs); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/cartcreates.c000644 001750 001750 00000002324 12342443662 022605 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" int main( int argc, char *argv[] ) { int errs = 0; int size, rank; int dims[2], periods[2]; MPI_Comm comm; MTest_Init( &argc, &argv ); /* Create a new cartesian communicator in a subset of the processes */ MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (size < 2) { fprintf( stderr, "This test needs at least 2 processes\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); } dims[0] = size-1; periods[0] = 1; MPI_Cart_create( MPI_COMM_WORLD, 1, dims, periods, 0, &comm ); if (comm != MPI_COMM_NULL) { int csize; MPI_Comm_size( comm, &csize ); if (csize != dims[0]) { errs++; fprintf( stderr, "Sizes is wrong in cart communicator. Is %d, should be %d\n", csize, dims[0] ); } MPI_Barrier( comm ); MPI_Comm_free( &comm ); } else if (rank < dims[0]) { errs++; fprintf( stderr, "Communicator returned is null!" ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/cartmap1.c000644 001750 001750 00000002571 12342443662 022021 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" int main( int argc, char *argv[] ) { int errs = 0; int dims[2]; int periods[2]; int size, rank, newrank; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); /* This defines a one dimensional cartision grid with a single point */ periods[0] = 1; dims[0] = 1; MPI_Cart_map( MPI_COMM_WORLD, 1, dims, periods, &newrank ); if (rank > 0) { if (newrank != MPI_UNDEFINED) { errs++; printf( "rank outside of input communicator not UNDEFINED\n" ); } } else { if (rank != newrank) { errs++; printf( "Newrank not defined and should be 0\n" ); } } /* As of MPI 2.1, a 0-dimensional topology is valid (its also a point) */ MPI_Cart_map( MPI_COMM_WORLD, 0, dims, periods, &newrank ); if (rank > 0) { if (newrank != MPI_UNDEFINED) { errs++; printf( "rank outside of input communicator not UNDEFINED\n" ); } } else { /* rank == 0 */ if (rank != newrank) { errs++; printf( "Newrank not defined and should be 0\n" ); } } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/graphmap1.c000644 001750 001750 00000002007 12342443662 022163 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" int main( int argc, char *argv[] ) { int errs = 0; int newrank, merr, rank; int index[2], edges[2]; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); /* Graph map where there are no nodes for this process */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); /* Here is a singleton graph, containing only the root process */ index[0] = 0; edges[0] = 0; merr = MPI_Graph_map( MPI_COMM_WORLD, 1, index, edges, &newrank ); if (merr) { errs++; printf( "Graph map returned an error\n" ); MTestPrintError( merr ); } if (rank != 0 && newrank != MPI_UNDEFINED) { errs++; printf( "Graph map with no local nodes did not return MPI_UNDEFINED\n" ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/neighb_coll.c000644 001750 001750 00000013376 12342443662 022563 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2012 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include #include #include "mpitest.h" #if !defined(USE_STRICT_MPI) && defined(MPICH) #define TEST_NEIGHB_COLL 1 #endif /* assert-like macro that bumps the err count and emits a message */ #define check(x_) \ do { \ if (!(x_)) { \ ++errs; \ if (errs < 10) { \ fprintf(stderr, "check failed: (%s), line %d\n", #x_, __LINE__); \ } \ } \ } while (0) int main(int argc, char *argv[]) { int errs = 0; int wrank, wsize; int periods[1] = { 0 }; MPI_Comm cart, dgraph, graph; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &wrank); MPI_Comm_size(MPI_COMM_WORLD, &wsize); #if defined(TEST_NEIGHB_COLL) /* a basic test for the 10 (5 patterns x {blocking,nonblocking}) MPI-3 * neighborhood collective routines */ /* (wrap)--> 0 <--> 1 <--> ... <--> p-1 <--(wrap) */ MPI_Cart_create(MPI_COMM_WORLD, 1, &wsize, periods, /*reorder=*/0, &cart); /* allgather */ { int sendbuf[1] = { wrank }; int recvbuf[2] = { 0xdeadbeef, 0xdeadbeef }; /* should see one send to each neighbor (rank-1 and rank+1) and one receive * each from same */ MPI_Neighbor_allgather(sendbuf, 1, MPI_INT, recvbuf, 1, MPI_INT, cart); if (wrank == 0) check(recvbuf[0] == 0xdeadbeef); else check(recvbuf[0] == wrank - 1); if (wrank == wsize - 1) check(recvbuf[1] == 0xdeadbeef); else check(recvbuf[1] == wrank + 1); } /* allgatherv */ { int sendbuf[1] = { wrank }; int recvbuf[2] = { 0xdeadbeef, 0xdeadbeef }; int recvcounts[2] = { 1, 1 }; int displs[2] = { 1, 0}; /* should see one send to each neighbor (rank-1 and rank+1) and one receive * each from same, but put them in opposite slots in the buffer */ MPI_Neighbor_allgatherv(sendbuf, 1, MPI_INT, recvbuf, recvcounts, displs, MPI_INT, cart); if (wrank == 0) check(recvbuf[1] == 0xdeadbeef); else check(recvbuf[1] == wrank - 1); if (wrank == wsize - 1) check(recvbuf[0] == 0xdeadbeef); else check(recvbuf[0] == wrank + 1); } /* alltoall */ { int sendbuf[2] = { -(wrank+1), wrank+1 }; int recvbuf[2] = { 0xdeadbeef, 0xdeadbeef }; /* should see one send to each neighbor (rank-1 and rank+1) and one * receive each from same */ MPI_Neighbor_alltoall(sendbuf, 1, MPI_INT, recvbuf, 1, MPI_INT, cart); if (wrank == 0) check(recvbuf[0] == 0xdeadbeef); else check(recvbuf[0] == wrank); if (wrank == wsize - 1) check(recvbuf[1] == 0xdeadbeef); else check(recvbuf[1] == -(wrank + 2)); } /* alltoallv */ { int sendbuf[2] = { -(wrank+1), wrank+1 }; int recvbuf[2] = { 0xdeadbeef, 0xdeadbeef }; int sendcounts[2] = { 1, 1 }; int recvcounts[2] = { 1, 1 }; int sdispls[2] = { 0, 1 }; int rdispls[2] = { 1, 0 }; /* should see one send to each neighbor (rank-1 and rank+1) and one receive * each from same, but put them in opposite slots in the buffer */ MPI_Neighbor_alltoallv(sendbuf, sendcounts, sdispls, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT, cart); if (wrank == 0) check(recvbuf[1] == 0xdeadbeef); else check(recvbuf[1] == wrank); if (wrank == wsize - 1) check(recvbuf[0] == 0xdeadbeef); else check(recvbuf[0] == -(wrank + 2)); } /* alltoallw */ { int sendbuf[2] = { -(wrank+1), wrank+1 }; int recvbuf[2] = { 0xdeadbeef, 0xdeadbeef }; int sendcounts[2] = { 1, 1 }; int recvcounts[2] = { 1, 1 }; MPI_Aint sdispls[2] = { 0, sizeof(int) }; MPI_Aint rdispls[2] = { sizeof(int), 0 }; MPI_Datatype sendtypes[2] = { MPI_INT, MPI_INT }; MPI_Datatype recvtypes[2] = { MPI_INT, MPI_INT }; /* should see one send to each neighbor (rank-1 and rank+1) and one receive * each from same, but put them in opposite slots in the buffer */ MPI_Neighbor_alltoallw(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, cart); if (wrank == 0) check(recvbuf[1] == 0xdeadbeef); else check(recvbuf[1] == wrank); if (wrank == wsize - 1) check(recvbuf[0] == 0xdeadbeef); else check(recvbuf[0] == -(wrank + 2)); } MPI_Comm_free(&cart); #endif /* defined(TEST_NEIGHB_COLL) */ MPI_Reduce((wrank == 0 ? MPI_IN_PLACE : &errs), &errs, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); if (wrank == 0) { if (errs) { printf("found %d errors\n", errs); } else { printf(" No errors\n"); } } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/dgraph_unwgt.c000644 001750 001750 00000013200 12342443662 022771 0ustar00cici000000 000000 #include #include #include #include "mpi.h" #include "mpitest.h" #define RING_NUM_NEIGHBORS 2 static int validate_dgraph(MPI_Comm dgraph_comm) { int comm_topo; int src_sz, dest_sz; int wgt_flag, ierr; int srcs[RING_NUM_NEIGHBORS], dests[RING_NUM_NEIGHBORS]; int *src_wgts, *dest_wgts; int world_rank, world_size; int idx, nbr_sep; comm_topo = MPI_UNDEFINED; MPI_Topo_test(dgraph_comm, &comm_topo); switch (comm_topo) { case MPI_DIST_GRAPH : break; default: fprintf(stderr, "dgraph_comm is NOT of type MPI_DIST_GRAPH\n"); return 0; } ierr = MPI_Dist_graph_neighbors_count(dgraph_comm, &src_sz, &dest_sz, &wgt_flag); if (ierr != MPI_SUCCESS) { fprintf(stderr, "MPI_Dist_graph_neighbors_count() fails!\n"); return 0; } /* else fprintf(stderr, "MPI_Dist_graph_neighbors_count() succeeds!\n"); */ if (wgt_flag) { fprintf(stderr, "dgraph_comm is NOT created with MPI_UNWEIGHTED\n"); return 0; } /* else fprintf(stderr, "dgraph_comm is created with MPI_UNWEIGHTED\n"); */ if (src_sz != RING_NUM_NEIGHBORS || dest_sz != RING_NUM_NEIGHBORS) { fprintf(stderr, "source or destination edge array is not of size %d.\n", RING_NUM_NEIGHBORS); fprintf(stderr, "src_sz = %d, dest_sz = %d\n", src_sz, dest_sz); return 0; } /* src_wgts and dest_wgts could be anything, e.g. NULL, since MPI_Dist_graph_neighbors_count() returns MPI_UNWEIGHTED. Since this program has a Fortran77 version, and standard Fortran77 has no pointer and NULL, so use MPI_UNWEIGHTED for the weighted arrays. */ src_wgts = MPI_UNWEIGHTED; dest_wgts = MPI_UNWEIGHTED; ierr = MPI_Dist_graph_neighbors(dgraph_comm, src_sz, srcs, src_wgts, dest_sz, dests, dest_wgts); if (ierr != MPI_SUCCESS) { fprintf(stderr, "MPI_Dist_graph_neighbors() fails!\n"); return 0; } /* else fprintf(stderr, "MPI_Dist_graph_neighbors() succeeds!\n"); */ /* Check if the neighbors returned from MPI are really the nearest neighbors within a ring. */ MPI_Comm_size(MPI_COMM_WORLD, &world_size); MPI_Comm_rank(MPI_COMM_WORLD, &world_rank); for (idx=0; idx < src_sz; idx++) { nbr_sep = abs(srcs[idx] - world_rank); if ( nbr_sep != 1 && nbr_sep != (world_size-1) ) { fprintf(stderr, "srcs[%d]=%d is NOT a neighbor of my rank %d.\n", idx, srcs[idx], world_rank); return 0; } } for (idx=0; idx < dest_sz; idx++) { nbr_sep = abs(dests[idx] - world_rank); if ( nbr_sep != 1 && nbr_sep != (world_size-1) ) { fprintf(stderr, "dests[%d]=%d is NOT a neighbor of my rank %d.\n", idx, dests[idx], world_rank); return 0; } } /* fprintf(stderr, "dgraph_comm is of type MPI_DIST_GRAPH " "of a bidirectional ring.\n"); */ return 1; } /* Specify a distributed graph of a bidirectional ring of the MPI_COMM_WORLD, i.e. everyone only talks to left and right neighbors. */ int main(int argc, char *argv[]) { MPI_Comm dgraph_comm; int world_size, world_rank, ierr; int errs = 0; int src_sz, dest_sz; int degs[1]; int srcs[RING_NUM_NEIGHBORS], dests[RING_NUM_NEIGHBORS]; MTest_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &world_size); MPI_Comm_rank(MPI_COMM_WORLD, &world_rank); degs[0] = 2; srcs[0] = world_rank; dests[0] = world_rank-1 < 0 ? world_size-1 : world_rank-1 ; dests[1] = world_rank+1 >= world_size ? 0 : world_rank+1 ; ierr = MPI_Dist_graph_create(MPI_COMM_WORLD, 1, srcs, degs, dests, MPI_UNWEIGHTED, MPI_INFO_NULL, 1, &dgraph_comm); if ( ierr != MPI_SUCCESS ) { fprintf(stderr, "MPI_Dist_graph_create() fails!\n"); MPI_Abort(MPI_COMM_WORLD, 1); return 1; } if (!validate_dgraph(dgraph_comm)) { fprintf(stderr, "MPI_Dist_graph_create() does NOT create " "a bidirectional ring graph!\n"); MPI_Abort(MPI_COMM_WORLD, 1); return 1; } MPI_Comm_free(&dgraph_comm); src_sz = 2; srcs[0] = world_rank-1 < 0 ? world_size-1 : world_rank-1 ; srcs[1] = world_rank+1 >= world_size ? 0 : world_rank+1 ; dest_sz = 2; dests[0] = world_rank-1 < 0 ? world_size-1 : world_rank-1 ; dests[1] = world_rank+1 >= world_size ? 0 : world_rank+1 ; ierr = MPI_Dist_graph_create_adjacent(MPI_COMM_WORLD, src_sz, srcs, MPI_UNWEIGHTED, dest_sz, dests, MPI_UNWEIGHTED, MPI_INFO_NULL, 1, &dgraph_comm); if ( ierr != MPI_SUCCESS ) { fprintf(stderr, "MPI_Dist_graph_create_adjacent() fails!\n"); MPI_Abort(MPI_COMM_WORLD, 1); return 1; } if (!validate_dgraph(dgraph_comm)) { fprintf(stderr, "MPI_Dist_graph_create_adjacent() does NOT create " "a bidirectional ring graph!\n"); MPI_Abort(MPI_COMM_WORLD, 1); return 1; } MPI_Comm_free(&dgraph_comm); MTest_Finalize(errs); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/dims1.c000644 001750 001750 00000010315 12342443662 021321 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" int prodof( int ndims, const int dims[] ); int increasing( int ndims, const int dims[] ); int prodof( int ndims, const int dims[] ) { int i, prod=1; for (i=0; i dims[i-1]) { printf ("%d = dims[%d] > dims[%d] = %d\n", dims[i], i, i-1, dims[i-1] ); err = 1; } } return err; } int main( int argc, char *argv[] ) { int errs = 0; int dims[4], nnodes, ndims; MTest_Init( &argc, &argv ); /* Test multiple dims create values. For each, make sure that the product of dims is the number of input nodes */ nnodes = 2*3*5*7*11; ndims = 2; dims[0] = dims[1] = 0; MPI_Dims_create( nnodes, ndims, dims ); if (prodof(ndims,dims) != nnodes) { errs++; printf( "dims create returned the wrong decomposition for %d in %d dims\n", nnodes, ndims ); } if (increasing( ndims, dims )) { errs++; printf( "dims create returned a decomposition with increasing dimensions (see MPI-1 standard section 6.5)\n" ); printf( "dims create returned the wrong decomposition for %d in %d dims\n", nnodes, ndims ); } /* Test multiple dims create values. For each, make sure that the product of dims is the number of input nodes */ nnodes = 2*7; ndims = 2; dims[0] = dims[1] = 0; MPI_Dims_create( nnodes, ndims, dims ); if (prodof(ndims,dims) != nnodes) { errs++; printf( "dims create returned the wrong decomposition for %d in %d dims\n", nnodes, ndims ); } if (increasing( ndims, dims )) { errs++; printf( "dims create returned a decomposition with increasing dimensions (see MPI-1 standard section 6.5)\n" ); printf( "dims create returned the wrong decomposition for %d in %d dims\n", nnodes, ndims ); } nnodes = 2*2*3*3*5*7*11; ndims = 2; dims[0] = dims[1] = 0; MPI_Dims_create( nnodes, ndims, dims ); if (prodof(ndims,dims) != nnodes) { errs++; printf( "dims create returned the wrong decomposition for %d in %d dims\n", nnodes, ndims ); } if (increasing( ndims, dims )) { errs++; printf( "dims create returned a decomposition with increasing dimensions (see MPI-1 standard section 6.5)\n" ); printf( "dims create returned the wrong decomposition for %d in %d dims\n", nnodes, ndims ); } nnodes = 11; ndims = 2; dims[0] = dims[1] = 0; MPI_Dims_create( nnodes, ndims, dims ); if (prodof(ndims,dims) != nnodes) { errs++; printf( "dims create returned the wrong decomposition for %d in %d dims\n", nnodes, ndims ); } if (increasing( ndims, dims )) { errs++; printf( "dims create returned a decomposition with increasing dimensions (see MPI-1 standard section 6.5)\n" ); printf( "dims create returned the wrong decomposition for %d in %d dims\n", nnodes, ndims ); } nnodes = 5*7*11; ndims = 4; dims[0] = dims[1] = dims[2] = dims[3] = 0; MPI_Dims_create( nnodes, ndims, dims ); if (prodof(ndims,dims) != nnodes) { errs++; printf( "dims create returned the wrong decomposition for %d in %d dims\n", nnodes, ndims ); } if (increasing( ndims, dims )) { errs++; printf( "dims create returned a decomposition with increasing dimensions (see MPI-1 standard section 6.5)\n" ); printf( "dims create returned the wrong decomposition for %d in %d dims\n", nnodes, ndims ); } nnodes = 64; ndims = 4; dims[0] = dims[1] = dims[2] = dims[3] = 0; MPI_Dims_create( nnodes, ndims, dims ); if (prodof(ndims,dims) != nnodes) { errs++; printf( "dims create returned the wrong decomposition for %d in %d dims\n", nnodes, ndims ); } if (increasing( ndims, dims )) { errs++; printf( "dims create returned a decomposition with increasing dimensions (see MPI-1 standard section 6.5)\n" ); printf( "dims create returned the wrong decomposition for %d in %d dims\n", nnodes, ndims ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/cartzero.c000644 001750 001750 00000004324 12342443662 022140 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2008 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" /* Check that the MPI implementation properly handles zero-dimensional Cartesian communicators - the original standard implies that these should be consistent with higher dimensional topologies and thus these should work with any MPI implementation. MPI 2.1 made this requirement explicit. */ int main( int argc, char *argv[] ) { int errs = 0; int size, rank, ndims; MPI_Comm comm, newcomm; MTest_Init( &argc, &argv ); /* Create a new cartesian communicator in a subset of the processes */ MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); if (size < 2) { fprintf( stderr, "This test needs at least 2 processes\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); } MPI_Cart_create( MPI_COMM_WORLD, 0, NULL, NULL, 0, &comm ); if (comm != MPI_COMM_NULL) { int csize; MPI_Comm_size( comm, &csize ); if (csize != 1) { errs++; fprintf( stderr, "Sizes is wrong in cart communicator. Is %d, should be 1\n", csize ); } /* This function is not meaningful, but should not fail */ MPI_Dims_create(1, 0, NULL); ndims = -1; MPI_Cartdim_get(comm, &ndims); if (ndims != 0) { errs++; fprintf(stderr, "MPI_Cartdim_get: ndims is %d, should be 0\n", ndims); } /* this function should not fail */ MPI_Cart_get(comm, 0, NULL, NULL, NULL); MPI_Cart_rank(comm, NULL, &rank); if (rank != 0) { errs++; fprintf(stderr, "MPI_Cart_rank: rank is %d, should be 0\n", rank); } /* this function should not fail */ MPI_Cart_coords(comm, 0, 0, NULL); MPI_Cart_sub(comm, NULL, &newcomm); ndims = -1; MPI_Cartdim_get(newcomm, &ndims); if (ndims != 0) { errs++; fprintf(stderr, "MPI_Cart_sub did not return zero-dimensional communicator\n"); } MPI_Barrier( comm ); MPI_Comm_free( &comm ); MPI_Comm_free( &newcomm ); } else if (rank == 0) { errs++; fprintf( stderr, "Communicator returned is null!" ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/dims2.c000644 001750 001750 00000004247 12342443662 021331 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" int prodof( int, const int[] ); /* * Test edge cases of Dims_create */ int prodof( int ndims, const int dims[] ) { int i, prod=1; for (i=0; i #include "mpitest.h" int main( int argc, char *argv[] ) { int errs = 0; int size, dims[2], periods[2], remain[2]; int result, rank; MPI_Comm comm, newcomm; MTest_Init( &argc, &argv ); /* First, create a 1-dim cartesian communicator */ periods[0] = 0; MPI_Comm_size( MPI_COMM_WORLD, &size ); dims[0] = size; MPI_Cart_create( MPI_COMM_WORLD, 1, dims, periods, 0, &comm ); /* Now, extract a communicator with no dimensions */ remain[0] = 0; MPI_Cart_sub( comm, remain, &newcomm ); MPI_Comm_rank(comm, &rank); if (rank == 0) { /* This should be congruent to MPI_COMM_SELF */ MPI_Comm_compare( MPI_COMM_SELF, newcomm, &result ); if (result != MPI_CONGRUENT) { errs++; printf( "cart sub to size 0 did not give self\n" ); } MPI_Comm_free( &newcomm ); } else if (newcomm != MPI_COMM_NULL) { errs++; printf( "cart sub to size 0 did not give null\n" ); } /* Free the new communicator so that storage leak tests will be happy */ MPI_Comm_free( &comm ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/topo/graphcr2.c000644 001750 001750 00000003620 12342443662 022015 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Create a communicator with a graph that contains null edges and one that contains duplicate edges"; */ int main( int argc, char *argv[] ) { int errs = 0; int *index = 0, *edges = 0; int rank, size, i, j, crank, csize; MPI_Comm comm; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); index = (int *)malloc( size*sizeof(int) ); edges = (int *)malloc( size*sizeof(int) ); for (i=0; i. For example, if they are in /usr/local/mympi/bin, use ./configure --with-mpi=/usr/local/mympi (configure will append the bin to the path that you give). You may need to add MPI_SIZEOF_OFFSET=8 . The option "-cpp" is needed for at least some versions of mpCC to define the C++ bindings of the MPI routines. For implementations that do not implement all of MPI-2, there are --disable options, including --disable-spawn and --disable-cxx. To restrict tests to just what is defined in the MPI specification, use --enable-strictmpi . The script that runs the tests assumes that the MPI implementation supports mpiexec; you should consider this the first test of the implementation. Setting Options =============== The following environment variables will modify the behavior of the tests MPITEST_DEBUG - if set, output information for debugging the test suite MPITEST_VERBOSE - if set to an integer value, output messages whose level is at least that value (0 is a good choice here) MPITEST_RETURN_WITH_CODE - Set the return code from the test programs based on success or failure, with a zero for success and one for failure (value must be yes, YES, true, or TRUE to turn this on) MPITEST_THREADLEVEL_DEFAULT - Set the default thread level. Values are multiple, serialized, funneled, and single. Batch Systems ============= For systems that run applications through a batch system, the option "-batch" to the runtests script will create a script file that can be edited and submitted to the batch system. The script checktests can be run to summarize the results. Specifically, (assuming the bash shell, and that the directory "btest", a subdirectory of the test suite directory, is used for running the tests): export MPITEST_BATCHDIR=`pwd`/btest runtests -batch -tests=testlist ... edit btest/runtests.batch to make it a value batch submissions script ... run that script and wait for the batch job to complete cd btest && ../checktests If a program other than mpiexec is used in the batch form to run programs, then specify that to runtests: runtests -batch -mpiexec=aprun -tests=testlist (Here, aprun is the command used on Cray XE6 systems.) Note that some programs that are used to run MPI programs add extra output, which can confuse any tool that depends on clean output in STDOUT. Since such unfortunate behavior is common, the option -ignorebogus can be given to checktests: cd btest && ../checktests --ignorebogus Controlling the Tests that are Run ================================== The tests are actually built and run by the script "runtests". This script can be given a file that contains a list of the tests to run. This file has two primary types of entries: directories: Enter directory and look for the file "testlist". Recursively run the contents of that file program names: Build and run that program Lines may also be commented out with "#". The simplest program line contains the name of the program and the number of MPI processes to use. For example, the following will build the program sendrecv1 and run it with 4 processes: sendrecv1 4 In addition, the program line can contain key=value pairs that provide special information about running the test. For example, sendflood 8 timeLimit=600 says to build and run the program sendflood with 8 MPI processes and permit the test to run for 600 seconds (by default, at least for MPICH, the default timelimit is 180 seconds). Other key=value pairs can be used to select whether a program should be run at all, depending on the abilities of the MPI implementation (this is particularly important for Fortran programs, since preprocessor support for Fortran is a non-standard extension to the Fortran language, and there are some compilers that would not accept Fortran programs that used the preprocessor). The most important key=value pairs are: timeLimit=n : Use a timelimit of n seconds arg=string : Run the program with string as an argument to the program mpiexecarg=string : Run the program with string as an argument to mpiexec env=name=value : Run the program with environment variable "name" given the value "value" mpiversion=x.y : Build and run the program only if the MPI version is at least x.y. For example, distgraph1 4 mpiversion=2.2 will build and run distgraph1 with 4 MPI processes only if the MPI version is at least 2.2. strict=bool : If bool is false, only build and run the program if --enable-strictmpi was not used in configuring the test suite. That is, a line such as neighb_coll 4 strict=false Says that this test is not valid for a strict MPI implementation; it contains extensions to the standard, or in the case of some MPICH development, MPIX routines resultTest=proc : This is used to change the way in which the success or failure of a test is evaluated. proc is one of several Perl subroutines defined within the runtest program. These are primarily used within the testsuite for tests programs exit with expected status values or that timeouts are in fact handled. SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/000755 001750 001750 00000000000 12342443666 020234 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/bsend5.c000644 001750 001750 00000003165 12342443662 021561 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include "mpi.h" #include "mpitest.h" #define BUFSIZE 2000 int main( int argc, char *argv[] ) { MPI_Status status; MPI_Comm comm,scomm; int a[10], b[10]; int buf[BUFSIZE], *bptr, bl, i, j, rank, size, color, errs=0; MTest_Init( 0, 0 ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); color = rank % 2; MPI_Comm_split( MPI_COMM_WORLD, color, rank, &scomm ); MPI_Intercomm_create( scomm, 0, MPI_COMM_WORLD, 1-color, 52, &comm); MPI_Comm_rank( comm, &rank ); MPI_Comm_remote_size( comm, &size ); MPI_Buffer_attach( buf, BUFSIZE ); for (j=0; j<10; j++) { for (i=0; i<10; i++) { a[i] = (rank + 10 * j) * size + i; } MPI_Bsend( a, 10, MPI_INT, 0, 27+j, comm ); } if (rank == 0) { for (i=0; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test of various send cancel calls"; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size, /* source, */ dest; MPI_Comm comm; MPI_Status status; MPI_Request req; static int bufsizes[4] = { 1, 100, 10000, 1000000 }; char *buf; #ifdef TEST_IRSEND int veryPicky = 0; /* Set to 1 to test "quality of implementation" in a tricky part of cancel */ #endif int cs, flag, n; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); /* source = 0; */ dest = size - 1; MTestPrintfMsg( 1, "Starting scancel test\n" ); for (cs=0; cs<4; cs++) { if (rank == 0) { n = bufsizes[cs]; buf = (char *)malloc( n ); if (!buf) { fprintf( stderr, "Unable to allocate %d bytes\n", n ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MTestPrintfMsg( 1, "(%d) About to create isend and cancel\n",cs ); MPI_Isend( buf, n, MPI_CHAR, dest, cs+n+1, comm, &req ); MPI_Cancel( &req ); MPI_Wait( &req, &status ); MTestPrintfMsg( 1, "Completed wait on isend\n" ); MPI_Test_cancelled( &status, &flag ); if (!flag) { errs ++; printf( "Failed to cancel an Isend request\n" ); fflush(stdout); } else { n = 0; } /* Send the size, zero for successfully cancelled */ MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); /* Send the tag so the message can be received */ n = cs+n+1; MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); free( buf ); } else if (rank == dest) { int nn, tag; char *btemp; MPI_Recv( &nn, 1, MPI_INT, 0, 123, comm, &status ); MPI_Recv( &tag, 1, MPI_INT, 0, 123, comm, &status ); if (nn > 0) { /* If the message was not cancelled, receive it here */ btemp = (char*)malloc( nn ); if (!btemp) { fprintf( stderr, "Unable to allocate %d bytes\n", nn ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Recv( btemp, nn, MPI_CHAR, 0, tag, comm, &status ); free(btemp); } } MPI_Barrier( comm ); if (rank == 0) { char *bsendbuf; int bsendbufsize; int bf, bs; n = bufsizes[cs]; buf = (char *)malloc( n ); if (!buf) { fprintf( stderr, "Unable to allocate %d bytes\n", n ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } bsendbufsize = n + MPI_BSEND_OVERHEAD; bsendbuf = (char *)malloc( bsendbufsize ); if (!bsendbuf) { fprintf( stderr, "Unable to allocate %d bytes for bsend\n", n ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Buffer_attach( bsendbuf, bsendbufsize ); MTestPrintfMsg( 1, "About to create and cancel ibsend\n" ); MPI_Ibsend( buf, n, MPI_CHAR, dest, cs+n+2, comm, &req ); MPI_Cancel( &req ); MPI_Wait( &req, &status ); MPI_Test_cancelled( &status, &flag ); if (!flag) { errs ++; printf( "Failed to cancel an Ibsend request\n" ); fflush(stdout); } else { n = 0; } /* Send the size, zero for successfully cancelled */ MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); /* Send the tag so the message can be received */ n = cs+n+2; MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); free( buf ); MPI_Buffer_detach( &bf, &bs ); free( bsendbuf ); } else if (rank == dest) { int nn, tag; char *btemp; MPI_Recv( &nn, 1, MPI_INT, 0, 123, comm, &status ); MPI_Recv( &tag, 1, MPI_INT, 0, 123, comm, &status ); if (nn > 0) { /* If the message was not cancelled, receive it here */ btemp = (char*)malloc( nn ); if (!btemp) { fprintf( stderr, "Unable to allocate %d bytes\n", nn); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Recv( btemp, nn, MPI_CHAR, 0, tag, comm, &status ); free(btemp); } } MPI_Barrier( comm ); /* Because this test is erroneous, we do not perform it unless TEST_IRSEND is defined. */ #ifdef TEST_IRSEND /* We avoid ready send to self because an implementation is free to detect the error in delivering a message to itself without a pending receive; we could also check for an error return from the MPI_Irsend */ if (rank == 0 && dest != rank) { n = bufsizes[cs]; buf = (char *)malloc( n ); if (!buf) { fprintf( stderr, "Unable to allocate %d bytes\n", n ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MTestPrintfMsg( 1, "About to create and cancel irsend\n" ); MPI_Irsend( buf, n, MPI_CHAR, dest, cs+n+3, comm, &req ); MPI_Cancel( &req ); MPI_Wait( &req, &status ); MPI_Test_cancelled( &status, &flag ); /* This can be pretty ugly. The standard is clear (Section 3.8) that either a sent message is received or the sent message is successfully cancelled. Since this message can never be received, the cancel must complete successfully. However, since there is no matching receive, this program is erroneous. In this case, we can't really flag this as an error */ if (!flag && veryPicky) { errs ++; printf( "Failed to cancel an Irsend request\n" ); fflush(stdout); } if (flag) { n = 0; } /* Send the size, zero for successfully cancelled */ MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); /* Send the tag so the message can be received */ n = cs+n+3; MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); free( buf ); } else if (rank == dest) { int n, tag; char *btemp; MPI_Recv( &n, 1, MPI_INT, 0, 123, comm, &status ); MPI_Recv( &tag, 1, MPI_INT, 0, 123, comm, &status ); if (n > 0) { /* If the message was not cancelled, receive it here */ btemp = (char*)malloc( n ); if (!btemp) { fprintf( stderr, "Unable to allocate %d bytes\n", n); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Recv( btemp, n, MPI_CHAR, 0, tag, comm, &status ); free(btemp); } } MPI_Barrier( comm ); #endif if (rank == 0) { n = bufsizes[cs]; buf = (char *)malloc( n ); if (!buf) { fprintf( stderr, "Unable to allocate %d bytes\n", n ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MTestPrintfMsg( 1, "About to create and cancel issend\n" ); MPI_Issend( buf, n, MPI_CHAR, dest, cs+n+4, comm, &req ); MPI_Cancel( &req ); MPI_Wait( &req, &status ); MPI_Test_cancelled( &status, &flag ); if (!flag) { errs ++; printf( "Failed to cancel an Issend request\n" ); fflush(stdout); } else { n = 0; } /* Send the size, zero for successfully cancelled */ MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); /* Send the tag so the message can be received */ n = cs+n+4; MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); free( buf ); } else if (rank == dest) { int nn, tag; char *btemp; MPI_Recv( &nn, 1, MPI_INT, 0, 123, comm, &status ); MPI_Recv( &tag, 1, MPI_INT, 0, 123, comm, &status ); if (nn > 0) { /* If the message was not cancelled, receive it here */ btemp = (char*)malloc( nn ); if (!btemp) { fprintf( stderr, "Unable to allocate %d bytes\n", nn); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Recv( btemp, nn, MPI_CHAR, 0, tag, comm, &status ); free(btemp); } } MPI_Barrier( comm ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/icsend.c000644 001750 001750 00000003150 12342443662 021640 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple test of intercommunicator send and receive"; */ int main( int argc, char *argv[] ) { int errs = 0; int leftGroup, buf, rank, remote_size, i; MPI_Comm comm; MPI_Status status; MTest_Init( &argc, &argv ); while (MTestGetIntercomm( &comm, &leftGroup, 4 )) { if (comm == MPI_COMM_NULL) continue; if (leftGroup) { MPI_Comm_rank( comm, &rank ); buf = rank; MPI_Send( &buf, 1, MPI_INT, 0, 0, comm ); } else { MPI_Comm_remote_size( comm, &remote_size ); MPI_Comm_rank( comm, &rank ); if (rank == 0) { for (i=0; i #include "mpitest.h" /* static char MTEST_Descrip[] = "Send-Recv"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int rank, size, source, dest; int minsize = 2, count; MPI_Comm comm; MTestDatatype sendtype, recvtype; MTest_Init( &argc, &argv ); /* The following illustrates the use of the routines to run through a selection of communicators and datatypes. Use subsets of these for tests that do not involve combinations of communicators, datatypes, and counts of datatypes */ while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); source = 0; dest = size - 1; /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN ); for (count = 1; count < 65000; count = count * 2) { while (MTestGetDatatypes( &sendtype, &recvtype, count )) { /* Make sure that everyone has a recv buffer */ recvtype.InitBuf( &recvtype ); if (rank == source) { sendtype.InitBuf( &sendtype ); err = MPI_Send( sendtype.buf, sendtype.count, sendtype.datatype, dest, 0, comm); if (err) { errs++; if (errs < 10) { MTestPrintError( err ); } } } else if (rank == dest) { err = MPI_Recv( recvtype.buf, recvtype.count, recvtype.datatype, source, 0, comm, MPI_STATUS_IGNORE); if (err) { errs++; if (errs < 10) { MTestPrintError( err ); } } err = MTestCheckRecv( 0, &recvtype ); if (err) { if (errs < 10) { printf( "Data in target buffer did not match for destination datatype %s and source datatype %s, count = %d\n", MTestGetDatatypeName( &recvtype ), MTestGetDatatypeName( &sendtype ), count ); recvtype.printErrors = 1; (void)MTestCheckRecv( 0, &recvtype ); } errs += err; } } MTestFreeDatatype( &sendtype ); MTestFreeDatatype( &recvtype ); } } MTestFreeComm( &comm ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/sendall.c000644 001750 001750 00000003364 12342443662 022024 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2007 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include "mpi.h" #include "mpitest.h" /* * This test makes sure that each process can send to each other process. * If there are bugs in the handling of request completions or in * queue operations, then this test may fail on them (it did with * early EagerShort handling). */ #define MAXPES 32 #define MYBUFSIZE 16*1024 static int buffer[MAXPES][MYBUFSIZE]; #define NUM_RUNS 10 int main ( int argc, char *argv[] ) { int i; int count, size; int self, npes; MPI_Request request[MAXPES]; MPI_Status status; MTest_Init (&argc, &argv); MPI_Comm_rank (MPI_COMM_WORLD, &self); MPI_Comm_size (MPI_COMM_WORLD, &npes); if (npes > MAXPES) { fprintf( stderr, "This program requires a comm_world no larger than %d", MAXPES ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } for (size = 1; size <= MYBUFSIZE ; size += size) { for (count = 0; count < NUM_RUNS; count++) { MPI_Barrier (MPI_COMM_WORLD); for (i = 0; i < npes; i++) { if (i != self) MPI_Irecv (buffer[i], size, MPI_INT, i, MPI_ANY_TAG, MPI_COMM_WORLD, &request[i]); } for (i = 0; i < npes; i++) { if (i != self) MPI_Send (buffer[self], size, MPI_INT, i, 0, MPI_COMM_WORLD); } for (i = 0; i < npes; i++) { if (i != self) MPI_Wait (&request[i], &status); } } MPI_Barrier (MPI_COMM_WORLD); if (self == 0) { MTestPrintfMsg( 1, "length = %d ints\n", size ); } } /* Simple completion is all that we normally ask of this program */ MTest_Finalize( 0 ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/inactivereq.c000644 001750 001750 00000007464 12342443662 022721 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2005 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* This test program checks that the point-to-point completion routines can be applied to an inactive persistent request, as required by the MPI-1 standard. See section 3.7.3, for example, One is allowed to call MPI TEST with a null or inactive request argument. In such a case the operation returns with flag = true and empty status. */ int StatusEmpty( MPI_Status *s ); int StatusEmpty( MPI_Status *s ) { int errs = 0; int count = 10; if (s->MPI_TAG != MPI_ANY_TAG) { errs++; printf( "MPI_TAG not MPI_ANY_TAG in status\n" ); } if (s->MPI_SOURCE != MPI_ANY_SOURCE) { errs++; printf( "MPI_SOURCE not MPI_ANY_SOURCE in status\n" ); } MPI_Get_count( s, MPI_INT, &count ); if (count != 0) { errs++; printf( "count in status is not 0\n" ); } /* Return true only if status passed all tests */ return errs ? 0 : 1; } int main(int argc, char *argv[]) { MPI_Request r; MPI_Status s; int errs = 0; int flag; int buf[10]; int rbuf[10]; int tag = 27; int dest = 0; int rank, size; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); /* Create a persistent send request */ MPI_Send_init( buf, 10, MPI_INT, dest, tag, MPI_COMM_WORLD, &r ); flag = 0; s.MPI_TAG = 10; s.MPI_SOURCE = 10; MPI_Test( &r, &flag, &s ); if (!flag) { errs++; printf( "Flag not true after MPI_Test (send)\n" ); printf( "Aborting further tests to avoid hanging in MPI_Wait\n" ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } if (!StatusEmpty( &s )) { errs++; printf( "Status not empty after MPI_Test (send)\n" ); } s.MPI_TAG = 10; s.MPI_SOURCE = 10; MPI_Wait( &r, &s ); if (!StatusEmpty( &s )) { errs++; printf( "Status not empty after MPI_Wait (send)\n" ); } /* Now try to use that request, then check again */ if (rank == 0) { int i; MPI_Request *rr = (MPI_Request *)malloc(size * sizeof(MPI_Request)); for (i=0; i #include #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif #include "mpi.h" static int verbose = 0; int parse_args(int argc, char **argv); int main(int argc, char *argv[]) { int i, err, errs = 0, rank, toterrs; int index; MPI_Request requests[10]; MPI_Status statuses[10]; MPI_Init(&argc, &argv); parse_args(argc, argv); for (i=0; i < 10; i++) { requests[i] = MPI_REQUEST_NULL; } /* begin testing */ /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); err = MPI_Waitany(10, requests, &index, statuses); if (err != MPI_SUCCESS) { errs++; fprintf(stderr, "MPI_Waitany did not return MPI_SUCCESS\n"); } if (index != MPI_UNDEFINED) { errs++; fprintf(stderr, "MPI_Waitany did not set index to MPI_UNDEFINED\n"); } /* end testing */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_ARE_FATAL ); MPI_Comm_rank( MPI_COMM_WORLD, & rank ); MPI_Allreduce( &errs, &toterrs, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD ); if (rank == 0) { if (toterrs) { fprintf(stderr, " Found %d errors\n", toterrs); } else { printf(" No Errors\n"); } } MPI_Finalize(); return 0; } int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/rqfreeb.c000644 001750 001750 00000006624 12342443662 022032 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2006 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* Test Ibsend and Request_free */ int main( int argc, char *argv[] ) { MPI_Comm comm = MPI_COMM_WORLD; int dest = 1, src = 0, tag = 1; int s1; char *buf, *bbuf; int smsg[5], rmsg[5]; int errs = 0, rank, size; int bufsize, bsize; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); if (src >= size || dest >= size) { int r = src; if (dest > r) r = dest; fprintf( stderr, "This program requires %d processes\n", r-1 ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } if (rank == src) { MPI_Request r; MPI_Barrier( MPI_COMM_WORLD ); /* According to the standard, we must use the PACK_SIZE length of each message in the computation of the message buffer size */ MPI_Pack_size( 5, MPI_INT, comm, &s1 ); bufsize = MPI_BSEND_OVERHEAD + s1 + 2000; buf = (char *)malloc( bufsize ); MPI_Buffer_attach( buf, bufsize ); MTestPrintfMsg( 10, "About create and free Isend request\n" ); smsg[0] = 10; MPI_Isend( &smsg[0], 1, MPI_INT, dest, tag, comm, &r ); MPI_Request_free( &r ); if (r != MPI_REQUEST_NULL) { errs++; fprintf( stderr, "Request not set to NULL after request free\n" ); } MTestPrintfMsg( 10, "About create and free Ibsend request\n" ); smsg[1] = 11; MPI_Ibsend( &smsg[1], 1, MPI_INT, dest, tag+1, comm, &r ); MPI_Request_free( &r ); if (r != MPI_REQUEST_NULL) { errs++; fprintf( stderr, "Request not set to NULL after request free\n" ); } MTestPrintfMsg( 10, "About create and free Issend request\n" ); smsg[2] = 12; MPI_Issend( &smsg[2], 1, MPI_INT, dest, tag+2, comm, &r ); MPI_Request_free( &r ); if (r != MPI_REQUEST_NULL) { errs++; fprintf( stderr, "Request not set to NULL after request free\n" ); } MTestPrintfMsg( 10, "About create and free Irsend request\n" ); smsg[3] = 13; MPI_Irsend( &smsg[3], 1, MPI_INT, dest, tag+3, comm, &r ); MPI_Request_free( &r ); if (r != MPI_REQUEST_NULL) { errs++; fprintf( stderr, "Request not set to NULL after request free\n" ); } smsg[4] = 14; MPI_Isend( &smsg[4], 1, MPI_INT, dest, tag+4, comm, &r ); MPI_Wait( &r, MPI_STATUS_IGNORE ); /* We can't guarantee that messages arrive until the detach */ MPI_Buffer_detach( &bbuf, &bsize ); } if (rank == dest) { MPI_Request r[5]; int i; for (i=0; i<5; i++) { MPI_Irecv( &rmsg[i], 1, MPI_INT, src, tag+i, comm, &r[i] ); } if (rank != src) /* Just in case rank == src */ MPI_Barrier( MPI_COMM_WORLD ); for (i=0; i<4; i++) { MPI_Wait( &r[i], MPI_STATUS_IGNORE ); if (rmsg[i] != 10+i) { errs++; fprintf( stderr, "message %d (%d) should be %d\n", i, rmsg[i], 10+i ); } } /* The MPI standard says that there is no way to use MPI_Request_free safely with receive requests. A strict MPI implementation may choose to consider these erroreous (an IBM MPI implementation does so) */ #ifdef USE_STRICT_MPI MPI_Wait( &r[4], MPI_STATUS_IGNORE ); #else MTestPrintfMsg( 10, "About free Irecv request\n" ); MPI_Request_free( &r[4] ); #endif } if (rank != dest && rank != src) { MPI_Barrier( MPI_COMM_WORLD ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/testlist000644 001750 001750 00000002233 12342443666 022032 0ustar00cici000000 000000 #needs MPI_Type_dup, MPI_Type_set_name #sendrecv1 4 sendrecv2 2 sendrecv3 2 sendflood 8 timeLimit=600 #needs rsend #sendself 1 sendall 4 anyall 2 eagerdt 2 #needs MPI_Type_get_name, MPI_Type_dup #pingping 2 bottom 2 #needs MPI_Bsend #bsend1 1 #bsend2 1 #bsend3 1 #bsend4 1 #bsend5 4 #bsendalign 2 #bsendpending 2 isendself 1 #needs MPI_Buffer_attach, MPI_Bsend, MPI_Buffer_detach #bsendfrag 2 #needs MPI_Intercomm_create #icsend 4 #needs MPI_Request_get_status #rqstatus 2 #needs MPI_Pack, MPI_Buffer_attach, MPI_Buffer_detach, MPI_Irsend, MPI_Ibsend #rqfreeb 4 #needs MPI_Grequest_start MPI_Grequest_complete #greq1 1 probe-unexp 4 probenull 1 # For testing, scancel will run with 1 process as well #needs MPI_Cancel, MPI_Test_cancelled, MPI_Ibsend #scancel 2 xfail=ticket287 #needs MPI_Cancel, MPI_Test_cancelled #scancel2 2 #pscancel 2 xfail=ticket287 #needs MPI_Cancel #rcancel 2 #cancelrecv 2 xfail=ticket287 isendselfprobe 1 inactivereq 1 #needs MPI_Error_string, but fails with testany waittestnull 1 waitany-null 1 # this should be run only on machines with large amount of memory (>=8GB) # perhaps disable in the release tarball #large_message 3 mprobe 2 mpiversion=3.0 SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/scancel2.c000644 001750 001750 00000003631 12342443662 022071 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test of send cancel (failure) calls"; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size, source, dest; MPI_Comm comm; MPI_Status status; MPI_Request req; static int bufsizes[4] = { 1, 100, 10000, 1000000 }; char *buf; int cs, flag, n; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); source = 0; dest = size - 1; MTestPrintfMsg( 1, "Starting scancel test\n" ); for (cs=0; cs<4; cs++) { n = bufsizes[cs]; buf = (char *)malloc( n ); if (!buf) { fprintf( stderr, "Unable to allocate %d bytes\n", n ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } if (rank == source) { MTestPrintfMsg( 1, "(%d) About to create isend and cancel\n",cs ); MPI_Isend( buf, n, MPI_CHAR, dest, cs+n+1, comm, &req ); MPI_Barrier( comm ); MPI_Cancel( &req ); MPI_Wait( &req, &status ); MTestPrintfMsg( 1, "Completed wait on isend\n" ); MPI_Test_cancelled( &status, &flag ); if (flag) { errs ++; printf( "Cancelled a matched Isend request (msg size = %d)!\n", n ); fflush(stdout); } else { n = 0; } /* Send the size, zero for not cancelled (success) */ MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); } else if (rank == dest) { MPI_Recv( buf, n, MPI_CHAR, source, cs+n+1, comm, &status ); MPI_Barrier( comm ); MPI_Recv( &n, 1, MPI_INT, source, 123, comm, &status ); } else { MPI_Barrier( comm ); } MPI_Barrier( comm ); free( buf ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/anyall.c000644 001750 001750 00000004133 12342443662 021655 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2009 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" #define MAX_MSGS 30 /* static char MTEST_Descrip[] = "One implementation delivered incorrect data when an MPI recieve uses both ANY_SOURCE and ANY_TAG"; */ int main( int argc, char *argv[] ) { int wrank, wsize, master, worker, i, j, idx, count; int errs = 0; MPI_Request r[MAX_MSGS]; int buf[MAX_MSGS][MAX_MSGS]; MPI_Comm comm; MPI_Status status; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &wrank ); MPI_Comm_size( MPI_COMM_WORLD, &wsize ); comm = MPI_COMM_WORLD; master = 0; worker = 1; /* The test takes advantage of the ordering rules for messages*/ if (wrank == master) { /* Initialize the send buffer */ for (i=0; i #include #include #include "mpitest.h" /* tests send/recv of a message > 2GB. count=270M, type=long long run with 3 processes to exercise both shared memory and TCP in Nemesis tests*/ int main(int argc, char *argv[]) { int /* ierr, */ i,size,rank; int cnt = 270000000; MPI_Status status; long long *cols; int errs = 0; MTest_Init(&argc,&argv); /* need large memory */ if (sizeof(void *) < 8) { MTest_Finalize(errs); MPI_Finalize(); return 0; } /* ierr = */ MPI_Comm_size(MPI_COMM_WORLD,&size); /* ierr = */ MPI_Comm_rank(MPI_COMM_WORLD,&rank); if (size != 3) { fprintf(stderr,"[%d] usage: mpiexec -n 3 %s\n",rank,argv[0]); MPI_Abort(MPI_COMM_WORLD,1); exit(1); } cols = malloc(cnt*sizeof(long long)); if (cols == NULL) { printf("malloc of >2GB array failed\n"); errs++; MTest_Finalize(errs); MPI_Finalize(); return 0; } if (rank == 0) { for (i=0; i #include "mpi.h" #include "mpitest.h" #define BUFSIZE 2000 int main( int argc, char *argv[] ) { MPI_Status status; int a[10], b[10]; int buf[BUFSIZE], *bptr, bl, i, j, rank, size; int errs = 0; MTest_Init( 0, 0 ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Buffer_attach( buf, BUFSIZE ); for (j=0; j<10; j++) { for (i=0; i<10; i++) { a[i] = (rank + 10 * j) * size + i; } MPI_Bsend( a, 10, MPI_INT, 0, 27+j, MPI_COMM_WORLD ); } if (rank == 0) { for (i=0; i #include "mpi.h" #include "mpitest.h" /* * This program checks that MPI_Iprobe and MPI_Probe correctly handle * a source of MPI_PROC_NULL */ int main(int argc, char **argv) { int flag; int errs = 0; MPI_Status status; MTest_Init(&argc, &argv); MPI_Iprobe( MPI_PROC_NULL, 10, MPI_COMM_WORLD, &flag, &status ); if (!flag) { errs++; printf( "Iprobe of source=MPI_PROC_NULL returned flag=false\n" ); } else { if (status.MPI_SOURCE != MPI_PROC_NULL) { printf( "Status.MPI_SOURCE was %d, should be MPI_PROC_NULL\n", status.MPI_SOURCE ); errs++; } if (status.MPI_TAG != MPI_ANY_TAG) { printf( "Status.MPI_TAG was %d, should be MPI_ANY_TAGL\n", status.MPI_TAG ); errs++; } } /* If Iprobe failed, probe is likely to as well. Avoid a possible hang by testing Probe only if Iprobe test passed */ if (errs == 0) { MPI_Probe( MPI_PROC_NULL, 10, MPI_COMM_WORLD, &status ); if (status.MPI_SOURCE != MPI_PROC_NULL) { printf( "Status.MPI_SOURCE was %d, should be MPI_PROC_NULL\n", status.MPI_SOURCE ); errs++; } if (status.MPI_TAG != MPI_ANY_TAG) { printf( "Status.MPI_TAG was %d, should be MPI_ANY_TAGL\n", status.MPI_TAG ); errs++; } } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/pingping.c000644 001750 001750 00000006021 12342443662 022206 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Send flood test"; */ #define MAX_MSG_SIZE 40000000 #define MAX_COUNT 4000 int main( int argc, char *argv[] ) { int errs = 0, err; int rank, size, source, dest; int minsize = 2, count, nmsg, maxmsg; MPI_Comm comm; MTestDatatype sendtype, recvtype; MTest_Init( &argc, &argv ); /* The following illustrates the use of the routines to run through a selection of communicators and datatypes. Use subsets of these for tests that do not involve combinations of communicators, datatypes, and counts of datatypes */ while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); source = 0; dest = size - 1; /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN ); for (count = 1; count < MAX_COUNT; count = count * 2) { while (MTestGetDatatypes( &sendtype, &recvtype, count )) { int nbytes; MPI_Type_size( sendtype.datatype, &nbytes ); /* We may want to limit the total message size sent */ if (nbytes > MAX_MSG_SIZE) { /* We do not need to free, as we haven't initialized any of the buffers (?) */ continue; } maxmsg = MAX_COUNT - count; MTestPrintfMsg( 1, "Sending count = %d of sendtype %s of total size %d bytes\n", count, MTestGetDatatypeName( &sendtype ), nbytes*count ); /* Make sure that everyone has a recv buffer */ recvtype.InitBuf( &recvtype ); if (rank == source) { sendtype.InitBuf( &sendtype ); for (nmsg=1; nmsg #include #include "mpitest.h" #include "mpitestconf.h" #ifdef HAVE_STRING_H #include #endif /* * This is a simple program that tests bsend. It may be run as a single * process to simplify debugging; in addition, bsend allows send-to-self * programs. */ int main( int argc, char *argv[] ) { MPI_Comm comm = MPI_COMM_WORLD; int dest = 0, src = 0, tag = 1; int s1, s2, s3; char *buf, *bbuf; char msg1[7], msg3[17]; double msg2[2]; char rmsg1[64], rmsg3[64]; double rmsg2[64]; int errs = 0, rank; int bufsize, bsize; MTest_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); /* According to the standard, we must use the PACK_SIZE length of each message in the computation of the message buffer size */ MPI_Pack_size( 7, MPI_CHAR, comm, &s1 ); MPI_Pack_size( 2, MPI_DOUBLE, comm, &s2 ); MPI_Pack_size( 17, MPI_CHAR, comm, &s3 ); bufsize = 3 * MPI_BSEND_OVERHEAD + s1 + s2 + s3; buf = (char *)malloc( bufsize ); MPI_Buffer_attach( buf, bufsize ); strncpy( msg1, "012345", 7 ); strncpy( msg3, "0123401234012341", 17 ); msg2[0] = 1.23; msg2[1] = 3.21; if (rank == src) { /* These message sizes are chosen to expose any alignment problems */ MPI_Bsend( msg1, 7, MPI_CHAR, dest, tag, comm ); MPI_Bsend( msg2, 2, MPI_DOUBLE, dest, tag, comm ); MPI_Bsend( msg3, 17, MPI_CHAR, dest, tag, comm ); } if (rank == dest) { MPI_Recv( rmsg1, 7, MPI_CHAR, src, tag, comm, MPI_STATUS_IGNORE ); MPI_Recv( rmsg2, 10, MPI_DOUBLE, src, tag, comm, MPI_STATUS_IGNORE ); MPI_Recv( rmsg3, 17, MPI_CHAR, src, tag, comm, MPI_STATUS_IGNORE ); if (strcmp( rmsg1, msg1 ) != 0) { errs++; fprintf( stderr, "message 1 (%s) should be %s\n", rmsg1, msg1 ); } if (rmsg2[0] != msg2[0] || rmsg2[1] != msg2[1]) { errs++; fprintf( stderr, "message 2 incorrect, values are (%f,%f) but should be (%f,%f)\n", rmsg2[0], rmsg2[1], msg2[0], msg2[1] ); } if (strcmp( rmsg3, msg3 ) != 0) { errs++; fprintf( stderr, "message 3 (%s) should be %s\n", rmsg3, msg3 ); } } /* We can't guarantee that messages arrive until the detach */ MPI_Buffer_detach( &bbuf, &bsize ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/waittestnull.c000644 001750 001750 00000004255 12342443662 023141 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2005 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include "mpi.h" #include "mpitest.h" /* * This program checks that the various MPI_Test and MPI_Wait routines * allow both null requests and in the multiple completion cases, empty * lists of requests. */ int main(int argc, char **argv) { int errs = 0; MPI_Status status, *status_array = 0; int count = 0, flag, idx, rc, errlen, *indices=0, outcnt; MPI_Request *reqs = 0; char errmsg[MPI_MAX_ERROR_STRING]; MTest_Init(&argc, &argv); MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); rc = MPI_Testall( count, reqs, &flag, status_array ); if (rc != MPI_SUCCESS) { MPI_Error_string( rc, errmsg, &errlen ); printf( "MPI_Testall returned failure: %s\n", errmsg ); errs ++; } else if (!flag) { printf( "MPI_Testall( 0, ... ) did not return a true flag\n") ; errs++; } rc = MPI_Waitall( count, reqs, status_array ); if (rc != MPI_SUCCESS) { MPI_Error_string( rc, errmsg, &errlen ); printf( "MPI_Waitall returned failure: %s\n", errmsg ); errs ++; } rc = MPI_Testany( count, reqs, &idx, &flag, &status ); if (rc != MPI_SUCCESS) { MPI_Error_string( rc, errmsg, &errlen ); printf( "MPI_Testany returned failure: %s\n", errmsg ); errs ++; } else if (!flag) { printf( "MPI_Testany( 0, ... ) did not return a true flag\n") ; errs++; } rc = MPI_Waitany( count, reqs, &idx, &status ); if (rc != MPI_SUCCESS) { MPI_Error_string( rc, errmsg, &errlen ); printf( "MPI_Waitany returned failure: %s\n", errmsg ); errs ++; } rc = MPI_Testsome( count, reqs, &outcnt, indices, status_array ); if (rc != MPI_SUCCESS) { MPI_Error_string( rc, errmsg, &errlen ); printf( "MPI_Testsome returned failure: %s\n", errmsg ); errs ++; } rc = MPI_Waitsome( count, reqs, &outcnt, indices, status_array ); if (rc != MPI_SUCCESS) { MPI_Error_string( rc, errmsg, &errlen ); printf( "MPI_Waitsome returned failure: %s\n", errmsg ); errs ++; } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/pscancel.c000644 001750 001750 00000017055 12342443662 022174 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test of various send cancel calls"; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size, /* source, */ dest; MPI_Comm comm; MPI_Status status; MPI_Request req; static int bufsizes[4] = { 1, 100, 10000, 1000000 }; char *buf; int cs, flag, n; #ifdef TEST_IRSEND int veryPicky = 0; /* Set to 1 to test "quality of implementation" in a tricky part of cancel */ #endif MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); /* source = 0; */ dest = size - 1; for (cs=0; cs<4; cs++) { if (rank == 0) { n = bufsizes[cs]; buf = (char *)malloc( n ); if (!buf) { fprintf( stderr, "Unable to allocate %d bytes\n", n ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Send_init( buf, n, MPI_CHAR, dest, cs+n+1, comm, &req ); MPI_Start( &req ); MPI_Cancel( &req ); MPI_Wait( &req, &status ); MPI_Test_cancelled( &status, &flag ); if (!flag) { errs ++; printf( "Failed to cancel a persistent send request\n" ); fflush(stdout); } else { n = 0; } MPI_Request_free( &req ); /* Send the size, zero for successfully cancelled */ MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); /* Send the tag so the message can be received */ n = cs+n+1; MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); free( buf ); } else if (rank == dest) { int nn, tag; char *btemp; MPI_Recv( &nn, 1, MPI_INT, 0, 123, comm, &status ); MPI_Recv( &tag, 1, MPI_INT, 0, 123, comm, &status ); if (nn > 0) { /* If the message was not cancelled, receive it here */ btemp = (char*)malloc( nn ); if (!btemp) { fprintf( stderr, "Unable to allocate %d bytes\n", nn); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Recv( btemp, nn, MPI_CHAR, 0, tag, comm, &status ); free(btemp); } } MPI_Barrier( comm ); if (rank == 0) { char *bsendbuf; int bsendbufsize; int bf, bs; n = bufsizes[cs]; buf = (char *)malloc( n ); if (!buf) { fprintf( stderr, "Unable to allocate %d bytes\n", n ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } bsendbufsize = n + MPI_BSEND_OVERHEAD; bsendbuf = (char *)malloc( bsendbufsize ); if (!bsendbuf) { fprintf( stderr, "Unable to allocate %d bytes for bsend\n", n ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Buffer_attach( bsendbuf, bsendbufsize ); MPI_Bsend_init( buf, n, MPI_CHAR, dest, cs+n+2, comm, &req ); MPI_Start( &req ); MPI_Cancel( &req ); MPI_Wait( &req, &status ); MPI_Test_cancelled( &status, &flag ); if (!flag) { errs ++; printf( "Failed to cancel a persistent bsend request\n" ); fflush(stdout); } else { n = 0; } MPI_Request_free( &req ); /* Send the size, zero for successfully cancelled */ MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); /* Send the tag so the message can be received */ n = cs+n+2; MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); free( buf ); MPI_Buffer_detach( &bf, &bs ); free( bsendbuf ); } else if (rank == dest) { int nn, tag; char *btemp; MPI_Recv( &nn, 1, MPI_INT, 0, 123, comm, &status ); MPI_Recv( &tag, 1, MPI_INT, 0, 123, comm, &status ); if (nn > 0) { /* If the message was not cancelled, receive it here */ btemp = (char*)malloc( nn ); if (!btemp) { fprintf( stderr, "Unable to allocate %d bytes\n", nn); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Recv( btemp, nn, MPI_CHAR, 0, tag, comm, &status ); free(btemp); } } MPI_Barrier( comm ); /* Because this test is erroneous, we do not perform it unless TEST_IRSEND is defined. */ #ifdef TEST_IRSEND /* We avoid ready send to self because an implementation is free to detect the error in delivering a message to itself without a pending receive; we could also check for an error return from the MPI_Irsend */ if (rank == 0 && dest != rank) { n = bufsizes[cs]; buf = (char *)malloc( n ); if (!buf) { fprintf( stderr, "Unable to allocate %d bytes\n", n ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Rsend_init( buf, n, MPI_CHAR, dest, cs+n+3, comm, &req ); MPI_Start( &req ); MPI_Cancel( &req ); MPI_Wait( &req, &status ); MPI_Test_cancelled( &status, &flag ); /* This can be pretty ugly. The standard is clear (Section 3.8) that either a sent message is received or the sent message is successfully cancelled. Since this message can never be received, the cancel must complete successfully. However, since there is no matching receive, this program is erroneous. In this case, we can't really flag this as an error */ if (!flag && veryPicky) { errs ++; printf( "Failed to cancel a persistent rsend request\n" ); fflush(stdout); } if (flag) { n = 0; } MPI_Request_free( &req ); /* Send the size, zero for successfully cancelled */ MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); /* Send the tag so the message can be received */ n = cs+n+3; MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); free( buf ); } else if (rank == dest) { int n, tag; char *btemp; MPI_Recv( &n, 1, MPI_INT, 0, 123, comm, &status ); MPI_Recv( &tag, 1, MPI_INT, 0, 123, comm, &status ); if (n > 0) { /* If the message was not cancelled, receive it here */ btemp = (char*)malloc( n ); if (!btemp) { fprintf( stderr, "Unable to allocate %d bytes\n", n); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Recv( btemp, n, MPI_CHAR, 0, tag, comm, &status ); free(btemp); } } MPI_Barrier( comm ); #endif if (rank == 0) { n = bufsizes[cs]; buf = (char *)malloc( n ); if (!buf) { fprintf( stderr, "Unable to allocate %d bytes\n", n ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Ssend_init( buf, n, MPI_CHAR, dest, cs+n+4, comm, &req ); MPI_Start( &req ); MPI_Cancel( &req ); MPI_Wait( &req, &status ); MPI_Test_cancelled( &status, &flag ); if (!flag) { errs ++; printf( "Failed to cancel a persistent ssend request\n" ); fflush(stdout); } else { n = 0; } MPI_Request_free( &req ); /* Send the size, zero for successfully cancelled */ MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); /* Send the tag so the message can be received */ n = cs+n+4; MPI_Send( &n, 1, MPI_INT, dest, 123, comm ); free( buf ); } else if (rank == dest) { int nn, tag; char *btemp; MPI_Recv( &nn, 1, MPI_INT, 0, 123, comm, &status ); MPI_Recv( &tag, 1, MPI_INT, 0, 123, comm, &status ); if (nn > 0) { /* If the message was not cancelled, receive it here */ btemp = (char*)malloc( nn ); if (!btemp) { fprintf( stderr, "Unable to allocate %d bytes\n", nn); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Recv( btemp, nn, MPI_CHAR, 0, tag, comm, &status ); free(btemp); } } MPI_Barrier( comm ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/eagerdt.c000644 001750 001750 00000004013 12342443662 022005 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2006 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test of a large number of derived-datatype messages eagerly, with no preposted receive so that an MPI implementation may have to queue up messages on the sending side"; */ #define MAX_MSGS 30 int main( int argc, char *argv[] ) { int errs = 0; int rank, size, dest, source; int i, indices[40]; MPI_Aint extent; int *buf, *bufs[MAX_MSGS]; MPI_Comm comm; MPI_Datatype dtype; MPI_Request req[MAX_MSGS]; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); source = 0; dest = size - 1; /* Setup by creating a blocked datatype that is likely to be processed in a piecemeal fashion */ for (i=0; i<30; i++) { indices[i] = i*40; } /* 30 blocks of size 10 */ MPI_Type_create_indexed_block( 30, 10, indices, MPI_INT, &dtype ); MPI_Type_commit( &dtype ); /* Create the corresponding message buffers */ MPI_Type_extent( dtype, &extent ); for (i=0; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test the handling of BSend operations when a detach occurs before the bsend data has been sent."; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size, source, dest; unsigned char *buf, *bufp; int minsize = 2; int i, msgsize, bufsize, outsize; unsigned char *msg1, *msg2, *msg3; MPI_Comm comm; MPI_Status status1, status2, status3; MTest_Init( &argc, &argv ); /* The following illustrates the use of the routines to run through a selection of communicators and datatypes. Use subsets of these for tests that do not involve combinations of communicators, datatypes, and counts of datatypes */ msgsize = 128 * 1024; msg1 = (unsigned char *)malloc( 3 * msgsize ); msg2 = msg1 + msgsize; msg3 = msg2 + msgsize; while (MTestGetIntracommGeneral( &comm, minsize, 1 )) { if (comm == MPI_COMM_NULL) continue; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); source = 0; dest = size - 1; /* Here is the test: The sender */ if (rank == source) { /* Get a bsend buffer. Make it large enough that the Bsend internals will (probably) not use a eager send for the data. Have three such messages */ bufsize = 3 * (MPI_BSEND_OVERHEAD + msgsize); buf = (unsigned char *)malloc( bufsize ); if (!buf) { fprintf( stderr, "Unable to allocate a buffer of %d bytes\n", bufsize ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Buffer_attach( buf, bufsize ); /* Initialize the buffers */ for (i=0; i #include #include "mpitest.h" #include /* For memset */ int main( int argc, char *argv[] ) { MPI_Request r[3]; MPI_Status s[3]; int *buf0, *buf1, *buf2; int rank, size, src, dest, flag, errs = 0; int n0, n1, n2; MPI_Comm comm; MTest_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &size ); if (size < 2) { fprintf( stderr, "Must run with at least 2 processes\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Comm_rank( MPI_COMM_WORLD, &rank ); dest = 0; src = 1; comm = MPI_COMM_WORLD; n0 = n1 = n2 = 65536; buf0 = (int *)malloc( n0 * sizeof(int) ); buf1 = (int *)malloc( n1 * sizeof(int) ); buf2 = (int *)malloc( n2 * sizeof(int) ); if (!buf0 || !buf1 || !buf2) { fprintf( stderr, "Unable to allocate buffers of size %d\n", n0 * (int)sizeof(int) ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } memset( buf0, -1, n0 * sizeof(int) ); memset( buf1, -1, n0 * sizeof(int) ); memset( buf2, -1, n0 * sizeof(int) ); if (rank == dest) { MPI_Irecv( buf0, n0, MPI_INT, src, 0, comm, &r[0] ); MPI_Irecv( buf1, n1, MPI_INT, src, 1, comm, &r[1] ); MPI_Irecv( buf2, n2, MPI_INT, src, 2, comm, &r[2] ); MPI_Barrier( comm ); MPI_Cancel( &r[1] ); MPI_Barrier( comm ); memset( s, -1, sizeof(s) ); MPI_Waitall( 3, r, s ); MPI_Test_cancelled( &s[0], &flag ); if (flag) { errs++; printf( "request 0 was cancelled!\n" ); } MPI_Test_cancelled( &s[1], &flag ); if (!flag) { errs++; printf( "request 1 was not cancelled!\n" ); } MPI_Test_cancelled( &s[2], &flag ); if (flag) { errs++; printf( "request 2 was cancelled!\n" ); } MPI_Barrier( comm ); } if (rank == src) { int tflag; MPI_Barrier( comm ); MPI_Barrier( comm ); MPI_Send( buf0, n0, MPI_INT, dest, 0, comm ); MPI_Isend( buf2, n2, MPI_INT, dest, 2, comm, &r[1] ); MPI_Isend( buf1, n1, MPI_INT, dest, 4, comm, &r[0] ); MPI_Cancel( &r[0] ); memset( s, -3, sizeof(s) ); s[0].MPI_ERROR = -3; s[1].MPI_ERROR = -3; MPI_Testall( 2, r, &tflag, s ); if (tflag) { MPI_Test_cancelled( &s[0], &flag ); if (!flag) { errs++; printf( "send request 0 was not cancelled!\n" ); } MPI_Test_cancelled( &s[1], &flag ); if (flag) { errs++; printf( "send request 1 was cancelled!\n" ); } } else { /* If all requests are not complete, then neither r nor s may be changed */ if ( (s[0].MPI_ERROR) != -3) { errs++; printf( "Send request status 0 modified. s[0].MPI_ERROR = %x\n", s[0].MPI_ERROR ); } if ( (s[1].MPI_ERROR) != -3) { errs++; printf( "Send request status 1 modified. s[1].MPI_ERROR = %x\n", s[1].MPI_ERROR ); } } MPI_Barrier( comm ); while (!tflag) { MPI_Testall( 2, r, &tflag, s ); } MPI_Test_cancelled( &s[0], &flag ); if (!flag) { errs++; printf( "send request 0 was not cancelled!\n" ); } MPI_Test_cancelled( &s[1], &flag ); if (flag) { errs++; printf( "send request 1 was cancelled!\n" ); } } if (rank != src && rank != dest) { MPI_Barrier( comm ); MPI_Barrier( comm ); MPI_Barrier( comm ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/mprobe.c000644 001750 001750 00000032061 12342443662 021662 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2012 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include #include "mpi.h" #include "mpitest.h" /* This is a temporary #ifdef to control whether we test this functionality. A * configure-test or similar would be better. Eventually the MPI-3 standard * will be released and this can be gated on a MPI_VERSION check */ #if !defined(USE_STRICT_MPI) && defined(MPICH) #define TEST_MPROBE_ROUTINES 1 #endif /* assert-like macro that bumps the err count and emits a message */ #define check(x_) \ do { \ if (!(x_)) { \ ++errs; \ if (errs < 10) { \ fprintf(stderr, "check failed: (%s), line %d\n", #x_, __LINE__); \ } \ } \ } while (0) int main(int argc, char **argv) { int errs = 0; int rank, size; #ifdef TEST_MPROBE_ROUTINES int found, completed; int sendbuf[8], recvbuf[8]; int count; MPI_Message msg; MPI_Request rreq; MPI_Status s1, s2; #endif MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); if (size < 2) { printf("this test requires at least 2 processes\n"); MPI_Abort(MPI_COMM_WORLD, 1); exit(1); } /* all processes besides ranks 0 & 1 aren't used by this test */ if (rank >= 2) { goto epilogue; } #ifdef TEST_MPROBE_ROUTINES /* test 0: simple send & mprobe+mrecv */ if (rank == 0) { sendbuf[0] = 0xdeadbeef; sendbuf[1] = 0xfeedface; MPI_Send(sendbuf, 2, MPI_INT, 1, 5, MPI_COMM_WORLD); } else { memset(&s1, 0xab, sizeof(MPI_Status)); memset(&s2, 0xab, sizeof(MPI_Status)); /* the error field should remain unmodified */ s1.MPI_ERROR = MPI_ERR_DIMS; s2.MPI_ERROR = MPI_ERR_TOPOLOGY; msg = MPI_MESSAGE_NULL; MPI_Mprobe(0, 5, MPI_COMM_WORLD, &msg, &s1); check(s1.MPI_SOURCE == 0); check(s1.MPI_TAG == 5); check(s1.MPI_ERROR == MPI_ERR_DIMS); check(msg != MPI_MESSAGE_NULL); count = -1; MPI_Get_count(&s1, MPI_INT, &count); check(count == 2); recvbuf[0] = 0x01234567; recvbuf[1] = 0x89abcdef; MPI_Mrecv(recvbuf, count, MPI_INT, &msg, &s2); check(recvbuf[0] == 0xdeadbeef); check(recvbuf[1] == 0xfeedface); check(s2.MPI_SOURCE == 0); check(s2.MPI_TAG == 5); check(s2.MPI_ERROR == MPI_ERR_TOPOLOGY); check(msg == MPI_MESSAGE_NULL); } /* test 1: simple send & mprobe+imrecv */ if (rank == 0) { sendbuf[0] = 0xdeadbeef; sendbuf[1] = 0xfeedface; MPI_Send(sendbuf, 2, MPI_INT, 1, 5, MPI_COMM_WORLD); } else { memset(&s1, 0xab, sizeof(MPI_Status)); memset(&s2, 0xab, sizeof(MPI_Status)); /* the error field should remain unmodified */ s1.MPI_ERROR = MPI_ERR_DIMS; s2.MPI_ERROR = MPI_ERR_TOPOLOGY; msg = MPI_MESSAGE_NULL; MPI_Mprobe(0, 5, MPI_COMM_WORLD, &msg, &s1); check(s1.MPI_SOURCE == 0); check(s1.MPI_TAG == 5); check(s1.MPI_ERROR == MPI_ERR_DIMS); check(msg != MPI_MESSAGE_NULL); count = -1; MPI_Get_count(&s1, MPI_INT, &count); check(count == 2); rreq = MPI_REQUEST_NULL; recvbuf[0] = 0x01234567; recvbuf[1] = 0x89abcdef; MPI_Imrecv(recvbuf, count, MPI_INT, &msg, &rreq); check(rreq != MPI_REQUEST_NULL); MPI_Wait(&rreq, &s2); check(recvbuf[0] == 0xdeadbeef); check(recvbuf[1] == 0xfeedface); check(s2.MPI_SOURCE == 0); check(s2.MPI_TAG == 5); check(s2.MPI_ERROR == MPI_ERR_TOPOLOGY); check(msg == MPI_MESSAGE_NULL); } /* test 2: simple send & improbe+mrecv */ if (rank == 0) { sendbuf[0] = 0xdeadbeef; sendbuf[1] = 0xfeedface; MPI_Send(sendbuf, 2, MPI_INT, 1, 5, MPI_COMM_WORLD); } else { memset(&s1, 0xab, sizeof(MPI_Status)); memset(&s2, 0xab, sizeof(MPI_Status)); /* the error field should remain unmodified */ s1.MPI_ERROR = MPI_ERR_DIMS; s2.MPI_ERROR = MPI_ERR_TOPOLOGY; msg = MPI_MESSAGE_NULL; do { check(msg == MPI_MESSAGE_NULL); MPI_Improbe(0, 5, MPI_COMM_WORLD, &found, &msg, &s1); } while (!found); check(msg != MPI_MESSAGE_NULL); check(s1.MPI_SOURCE == 0); check(s1.MPI_TAG == 5); check(s1.MPI_ERROR == MPI_ERR_DIMS); count = -1; MPI_Get_count(&s1, MPI_INT, &count); check(count == 2); recvbuf[0] = 0x01234567; recvbuf[1] = 0x89abcdef; MPI_Mrecv(recvbuf, count, MPI_INT, &msg, &s2); check(recvbuf[0] == 0xdeadbeef); check(recvbuf[1] == 0xfeedface); check(s2.MPI_SOURCE == 0); check(s2.MPI_TAG == 5); check(s2.MPI_ERROR == MPI_ERR_TOPOLOGY); check(msg == MPI_MESSAGE_NULL); } /* test 3: simple send & improbe+imrecv */ if (rank == 0) { sendbuf[0] = 0xdeadbeef; sendbuf[1] = 0xfeedface; MPI_Send(sendbuf, 2, MPI_INT, 1, 5, MPI_COMM_WORLD); } else { memset(&s1, 0xab, sizeof(MPI_Status)); memset(&s2, 0xab, sizeof(MPI_Status)); /* the error field should remain unmodified */ s1.MPI_ERROR = MPI_ERR_DIMS; s2.MPI_ERROR = MPI_ERR_TOPOLOGY; msg = MPI_MESSAGE_NULL; do { check(msg == MPI_MESSAGE_NULL); MPI_Improbe(0, 5, MPI_COMM_WORLD, &found, &msg, &s1); } while (!found); check(msg != MPI_MESSAGE_NULL); check(s1.MPI_SOURCE == 0); check(s1.MPI_TAG == 5); check(s1.MPI_ERROR == MPI_ERR_DIMS); count = -1; MPI_Get_count(&s1, MPI_INT, &count); check(count == 2); rreq = MPI_REQUEST_NULL; MPI_Imrecv(recvbuf, count, MPI_INT, &msg, &rreq); check(rreq != MPI_REQUEST_NULL); MPI_Wait(&rreq, &s2); check(recvbuf[0] == 0xdeadbeef); check(recvbuf[1] == 0xfeedface); check(s2.MPI_SOURCE == 0); check(s2.MPI_TAG == 5); check(s2.MPI_ERROR == MPI_ERR_TOPOLOGY); check(msg == MPI_MESSAGE_NULL); } /* test 4: mprobe+mrecv with MPI_PROC_NULL */ { memset(&s1, 0xab, sizeof(MPI_Status)); memset(&s2, 0xab, sizeof(MPI_Status)); /* the error field should remain unmodified */ s1.MPI_ERROR = MPI_ERR_DIMS; s2.MPI_ERROR = MPI_ERR_TOPOLOGY; msg = MPI_MESSAGE_NULL; MPI_Mprobe(MPI_PROC_NULL, 5, MPI_COMM_WORLD, &msg, &s1); check(s1.MPI_SOURCE == MPI_PROC_NULL); check(s1.MPI_TAG == MPI_ANY_TAG); check(s1.MPI_ERROR == MPI_ERR_DIMS); check(msg == MPI_MESSAGE_NO_PROC); count = -1; MPI_Get_count(&s1, MPI_INT, &count); check(count == 0); recvbuf[0] = 0x01234567; recvbuf[1] = 0x89abcdef; MPI_Mrecv(recvbuf, count, MPI_INT, &msg, &s2); /* recvbuf should remain unmodified */ check(recvbuf[0] == 0x01234567); check(recvbuf[1] == 0x89abcdef); /* should get back "proc null status" */ check(s2.MPI_SOURCE == MPI_PROC_NULL); check(s2.MPI_TAG == MPI_ANY_TAG); check(s2.MPI_ERROR == MPI_ERR_TOPOLOGY); check(msg == MPI_MESSAGE_NULL); count = -1; MPI_Get_count(&s2, MPI_INT, &count); check(count == 0); } /* test 5: mprobe+imrecv with MPI_PROC_NULL */ { memset(&s1, 0xab, sizeof(MPI_Status)); memset(&s2, 0xab, sizeof(MPI_Status)); /* the error field should remain unmodified */ s1.MPI_ERROR = MPI_ERR_DIMS; s2.MPI_ERROR = MPI_ERR_TOPOLOGY; msg = MPI_MESSAGE_NULL; MPI_Mprobe(MPI_PROC_NULL, 5, MPI_COMM_WORLD, &msg, &s1); check(s1.MPI_SOURCE == MPI_PROC_NULL); check(s1.MPI_TAG == MPI_ANY_TAG); check(s1.MPI_ERROR == MPI_ERR_DIMS); check(msg == MPI_MESSAGE_NO_PROC); count = -1; MPI_Get_count(&s1, MPI_INT, &count); check(count == 0); rreq = MPI_REQUEST_NULL; recvbuf[0] = 0x01234567; recvbuf[1] = 0x89abcdef; MPI_Imrecv(recvbuf, count, MPI_INT, &msg, &rreq); check(rreq != MPI_REQUEST_NULL); completed = 0; MPI_Test(&rreq, &completed, &s2); /* single test should always succeed */ check(completed); /* recvbuf should remain unmodified */ check(recvbuf[0] == 0x01234567); check(recvbuf[1] == 0x89abcdef); /* should get back "proc null status" */ check(s2.MPI_SOURCE == MPI_PROC_NULL); check(s2.MPI_TAG == MPI_ANY_TAG); check(s2.MPI_ERROR == MPI_ERR_TOPOLOGY); check(msg == MPI_MESSAGE_NULL); count = -1; MPI_Get_count(&s2, MPI_INT, &count); check(count == 0); } /* test 6: improbe+mrecv with MPI_PROC_NULL */ { memset(&s1, 0xab, sizeof(MPI_Status)); memset(&s2, 0xab, sizeof(MPI_Status)); /* the error field should remain unmodified */ s1.MPI_ERROR = MPI_ERR_DIMS; s2.MPI_ERROR = MPI_ERR_TOPOLOGY; msg = MPI_MESSAGE_NULL; found = 0; MPI_Improbe(MPI_PROC_NULL, 5, MPI_COMM_WORLD, &found, &msg, &s1); check(found); check(msg == MPI_MESSAGE_NO_PROC); check(s1.MPI_SOURCE == MPI_PROC_NULL); check(s1.MPI_TAG == MPI_ANY_TAG); check(s1.MPI_ERROR == MPI_ERR_DIMS); count = -1; MPI_Get_count(&s1, MPI_INT, &count); check(count == 0); recvbuf[0] = 0x01234567; recvbuf[1] = 0x89abcdef; MPI_Mrecv(recvbuf, count, MPI_INT, &msg, &s2); /* recvbuf should remain unmodified */ check(recvbuf[0] == 0x01234567); check(recvbuf[1] == 0x89abcdef); /* should get back "proc null status" */ check(s2.MPI_SOURCE == MPI_PROC_NULL); check(s2.MPI_TAG == MPI_ANY_TAG); check(s2.MPI_ERROR == MPI_ERR_TOPOLOGY); check(msg == MPI_MESSAGE_NULL); count = -1; MPI_Get_count(&s2, MPI_INT, &count); check(count == 0); } /* test 7: improbe+imrecv */ { memset(&s1, 0xab, sizeof(MPI_Status)); memset(&s2, 0xab, sizeof(MPI_Status)); /* the error field should remain unmodified */ s1.MPI_ERROR = MPI_ERR_DIMS; s2.MPI_ERROR = MPI_ERR_TOPOLOGY; msg = MPI_MESSAGE_NULL; MPI_Improbe(MPI_PROC_NULL, 5, MPI_COMM_WORLD, &found, &msg, &s1); check(found); check(msg == MPI_MESSAGE_NO_PROC); check(s1.MPI_SOURCE == MPI_PROC_NULL); check(s1.MPI_TAG == MPI_ANY_TAG); check(s1.MPI_ERROR == MPI_ERR_DIMS); count = -1; MPI_Get_count(&s1, MPI_INT, &count); check(count == 0); rreq = MPI_REQUEST_NULL; MPI_Imrecv(recvbuf, count, MPI_INT, &msg, &rreq); check(rreq != MPI_REQUEST_NULL); completed = 0; MPI_Test(&rreq, &completed, &s2); /* single test should always succeed */ check(completed); /* recvbuf should remain unmodified */ check(recvbuf[0] == 0x01234567); check(recvbuf[1] == 0x89abcdef); /* should get back "proc null status" */ check(s2.MPI_SOURCE == MPI_PROC_NULL); check(s2.MPI_TAG == MPI_ANY_TAG); check(s2.MPI_ERROR == MPI_ERR_TOPOLOGY); check(msg == MPI_MESSAGE_NULL); count = -1; MPI_Get_count(&s2, MPI_INT, &count); check(count == 0); } /* TODO MPI_ANY_SOURCE and MPI_ANY_TAG should be tested as well */ /* TODO a full range of message sizes should be tested too */ /* TODO threaded tests are also needed, but they should go in a separate * program */ /* simple test to ensure that c2f/f2c routines are present (initially missed * in MPICH impl) */ { MPI_Fint f_handle = 0xdeadbeef; f_handle = MPI_Message_c2f(MPI_MESSAGE_NULL); msg = MPI_Message_f2c(f_handle); check(f_handle != 0xdeadbeef); check(msg == MPI_MESSAGE_NULL); /* PMPI_ versions should also exists */ f_handle = 0xdeadbeef; f_handle = PMPI_Message_c2f(MPI_MESSAGE_NULL); msg = PMPI_Message_f2c(f_handle); check(f_handle != 0xdeadbeef); check(msg == MPI_MESSAGE_NULL); } #endif /* TEST_MPROBE_ROUTINES */ epilogue: MPI_Reduce((rank == 0 ? MPI_IN_PLACE : &errs), &errs, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); if (rank == 0) { if (errs) { printf("found %d errors\n", errs); } else { printf(" No errors\n"); } } MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/bsend3.c000644 001750 001750 00000002775 12342443662 021565 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include "mpi.h" #include "mpitest.h" #define BUFSIZE 2000 int main( int argc, char *argv[] ) { MPI_Status status; MPI_Request request; int a[10], b[10]; int buf[BUFSIZE], *bptr, bl, i, j, rank, size; int errs = 0; MTest_Init( 0, 0 ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Buffer_attach( buf, BUFSIZE ); for (j=0; j<10; j++) { MPI_Bsend_init( a, 10, MPI_INT, 0, 27+j, MPI_COMM_WORLD, &request ); for (i=0; i<10; i++) { a[i] = (rank + 10 * j) * size + i; } MPI_Start( &request ); MPI_Wait( &request, &status ); MPI_Request_free( &request ); } if (rank == 0) { for (i=0; i #include "mpitest.h" /* static char MTEST_Descrip[] = "Test Request_get_status"; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size, source, dest; int buf[2], flag, count; MPI_Comm comm; MPI_Status status, status2; MPI_Request req; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; /* Determine the sender and receiver */ MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); source = 0; dest = size - 1; /* Handling MPI_REQUEST_NULL in MPI_Request_get_status was only required starting with MPI-2.2. */ #if MTEST_HAVE_MIN_MPI_VERSION(2,2) MPI_Request_get_status( MPI_REQUEST_NULL, &flag, &status ); if (!flag) { errs++; fprintf( stderr, "flag not true for MPI_REQUEST_NULL, flag=%d\n", flag ); } if ((status.MPI_SOURCE != MPI_ANY_SOURCE) || (status.MPI_TAG != MPI_ANY_TAG) || (status.MPI_ERROR != MPI_SUCCESS)) { errs++; fprintf( stderr, "non-empty MPI_Status returned for MPI_REQUEST_NULL\n" ); } /* also pass MPI_STATUS_IGNORE to make sure the implementation doesn't * blow up when it is passed as the status argument */ MPI_Request_get_status( MPI_REQUEST_NULL, &flag, MPI_STATUS_IGNORE ); if (!flag) { errs++; fprintf( stderr, "flag not true for MPI_REQUEST_NULL with MPI_STATUS_IGNORE, flag=%d\n", flag ); } #endif if (rank == source) { buf[0] = size; buf[1] = 3; MPI_Ssend( buf, 2, MPI_INT, dest, 10, comm ); } if (rank == dest) { MPI_Irecv( buf, 2, MPI_INT, source, 10, comm, &req ); } MPI_Barrier( comm ); /* At this point, we know that the receive has at least started, because of the Ssend. Check the status on the request */ if (rank == dest) { status.MPI_SOURCE = -1; status.MPI_TAG = -1; MPI_Request_get_status( req, &flag, &status ); if (flag) { if (status.MPI_TAG != 10) { errs++; fprintf( stderr, "Tag value %d should be 10\n", status.MPI_TAG ); } if (status.MPI_SOURCE != source) { errs++; fprintf( stderr, "Source value %d should be %d\n", status.MPI_SOURCE, source ); } MPI_Get_count( &status, MPI_INT, &count ); if (count != 2) { errs++; fprintf( stderr, "Count value %d should be 2\n", count ); } } else { errs++; fprintf( stderr, "Unexpected flag value from get_status\n" ); } /* Now, complete the request */ MPI_Wait( &req, &status2 ); /* Check that the status is correct */ if (status2.MPI_TAG != 10) { errs++; fprintf( stderr, "(wait)Tag value %d should be 10\n", status2.MPI_TAG ); } if (status2.MPI_SOURCE != source) { errs++; fprintf( stderr, "(wait)Source value %d should be %d\n", status2.MPI_SOURCE, source ); } MPI_Get_count( &status2, MPI_INT, &count ); if (count != 2) { errs++; fprintf( stderr, "(wait)Count value %d should be 2\n", count ); } } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/bsendfrag.c000644 001750 001750 00000005740 12342443662 022335 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include "mpi.h" #include "mpitest.h" /* static char MTEST_Descrip[] = "Test bsend message handling where \ different messages are received in different orders"; */ /* * Notes on the test. * * To ensure that messages remain in the bsend buffer until received, * messages are sent with size MSG_SIZE (ints). */ #define MSG_SIZE 17000 int main( int argc, char *argv[] ) { int errs = 0; int b1[MSG_SIZE], b2[MSG_SIZE], b3[MSG_SIZE], b4[MSG_SIZE]; int src, dest, size, rank, i; MPI_Comm comm; MPI_Status status; MTest_Init( &argc, &argv ); MPI_Errhandler_set( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); if (size < 2) { errs++; fprintf( stderr, "At least 2 processes required\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } src = 0; dest = 1; if (rank == src) { int *buf, bufsize, bsize; bufsize = 4 * (MSG_SIZE * sizeof(int) + MPI_BSEND_OVERHEAD); buf = (int *)malloc( bufsize ); if (!buf) { fprintf( stderr, "Could not allocate buffer of %d bytes\n", bufsize ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } MPI_Buffer_attach( buf, bufsize ); /* Initialize data */ for (i=0; i #include "mpi.h" #include "mpitest.h" #define MAX_BUF_SIZE_LG 22 #define NUM_MSGS_PER_BUF_SIZE 5 char buf[1 << MAX_BUF_SIZE_LG]; /* * This program verifies that MPI_Probe() is operating properly in the face of * unexpected messages arriving after MPI_Probe() has * been called. This program may hang if MPI_Probe() does not return when the * message finally arrives (see req #375). */ int main(int argc, char **argv) { int p_size; int p_rank; int msg_size_lg; int errs = 0; int mpi_errno; MTest_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &p_size); MPI_Comm_rank(MPI_COMM_WORLD, &p_rank); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN ); for (msg_size_lg = 0; msg_size_lg <= MAX_BUF_SIZE_LG; msg_size_lg++) { const int msg_size = 1 << msg_size_lg; int msg_cnt; MTestPrintfMsg( 2, "testing messages of size %d\n", msg_size ); for (msg_cnt = 0; msg_cnt < NUM_MSGS_PER_BUF_SIZE; msg_cnt++) { MPI_Status status; const int tag = msg_size_lg * NUM_MSGS_PER_BUF_SIZE + msg_cnt; MTestPrintfMsg( 2, "Message count %d\n", msg_cnt ); if (p_rank == 0) { int p; for (p = 1; p < p_size; p ++) { /* Wait for synchronization message */ mpi_errno = MPI_Recv(NULL, 0, MPI_BYTE, MPI_ANY_SOURCE, tag, MPI_COMM_WORLD, &status); if (mpi_errno != MPI_SUCCESS && errs++ < 10) { MTestPrintError(mpi_errno); } if (status.MPI_TAG != tag && errs++ < 10) { printf("ERROR: unexpected message tag from MPI_Recv(): lp=0, rp=%d, expected=%d, actual=%d, count=%d\n", status.MPI_SOURCE, status.MPI_TAG, tag, msg_cnt); } # if defined(VERBOSE) { printf("sending message: p=%d s=%d c=%d\n", status.MPI_SOURCE, msg_size, msg_cnt); } # endif /* Send unexpected message which hopefully MPI_Probe() is already waiting for at the remote process */ mpi_errno = MPI_Send (buf, msg_size, MPI_BYTE, status.MPI_SOURCE, status.MPI_TAG, MPI_COMM_WORLD); if (mpi_errno != MPI_SUCCESS && errs++ < 10) { MTestPrintError(mpi_errno); } } } else { int incoming_msg_size; /* Send synchronization message */ mpi_errno = MPI_Send(NULL, 0, MPI_BYTE, 0, tag, MPI_COMM_WORLD); if (mpi_errno != MPI_SUCCESS && errs++ < 10) { MTestPrintError(mpi_errno); } /* Perform probe, hopefully before the master process can send its reply */ mpi_errno = MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status); if (mpi_errno != MPI_SUCCESS && errs++ < 10) { MTestPrintError(mpi_errno); } mpi_errno = MPI_Get_count(&status, MPI_BYTE, &incoming_msg_size); if (mpi_errno != MPI_SUCCESS && errs++ < 10) { MTestPrintError(mpi_errno); } if (status.MPI_SOURCE != 0 && errs++ < 10) { printf("ERROR: unexpected message source from MPI_Probe(): p=%d, expected=0, actual=%d, count=%d\n", p_rank, status.MPI_SOURCE, msg_cnt); } if (status.MPI_TAG != tag && errs++ < 10) { printf("ERROR: unexpected message tag from MPI_Probe(): p=%d, expected=%d, actual=%d, count=%d\n", p_rank, tag, status.MPI_TAG, msg_cnt); } if (incoming_msg_size != msg_size && errs++ < 10) { printf("ERROR: unexpected message size from MPI_Probe(): p=%d, expected=%d, actual=%d, count=%d\n", p_rank, msg_size, incoming_msg_size, msg_cnt); } /* Receive the probed message from the master process */ mpi_errno = MPI_Recv(buf, msg_size, MPI_BYTE, 0, tag, MPI_COMM_WORLD, &status); if (mpi_errno != MPI_SUCCESS && errs++ < 10) { MTestPrintError(mpi_errno); } mpi_errno = MPI_Get_count(&status, MPI_BYTE, &incoming_msg_size); if (mpi_errno != MPI_SUCCESS && errs++ < 10) { MTestPrintError(mpi_errno); } if (status.MPI_SOURCE != 0 && errs++ < 10) { printf("ERROR: unexpected message source from MPI_Recv(): p=%d, expected=0, actual=%d, count=%d\n", p_rank, status.MPI_SOURCE, msg_cnt); } if (status.MPI_TAG != tag && errs++ < 10) { printf("ERROR: unexpected message tag from MPI_Recv(): p=%d, expected=%d, actual=%d, count=%d\n", p_rank, tag, status.MPI_TAG, msg_cnt); } if (incoming_msg_size != msg_size && errs++ < 10) { printf("ERROR: unexpected message size from MPI_Recv(): p=%d, expected=%d, actual=%d, count=%d\n", p_rank, msg_size, incoming_msg_size, msg_cnt); } } } } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/sendrecv2.c000644 001750 001750 00000005331 12342443662 022271 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include "mpitestconf.h" #include #include #ifdef HAVE_STRING_H #include #endif static int verbose = 0; static int parse_args(int argc, char **argv); int main( int argc, char *argv[] ) { int i, j, errs = 0; int rank, size; MPI_Datatype newtype; char *buf = NULL; MPI_Init(&argc, &argv); parse_args(argc, argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); if (size < 2) { if (verbose) fprintf(stderr, "comm size must be > 1\n"); errs++; goto fn_exit; } buf = malloc(64 * 129); if (buf == NULL) { if (verbose) fprintf(stderr, "error allocating buffer\n"); errs++; goto fn_exit; } for (i = 8; i < 64; i += 4) { MPI_Type_vector(i, 128, 129, MPI_CHAR, &newtype); MPI_Type_commit(&newtype); memset(buf, 0, 64*129); if (rank == 0) { /* init buffer */ for (j=0; j < i; j++) { int k; for (k=0; k < 129; k++) { buf[129*j + k] = (char) j; } } /* send */ MPI_Send(buf, 1, newtype, 1, i, MPI_COMM_WORLD); } else if (rank == 1) { /* recv */ MPI_Recv(buf, 1, newtype, 0, i, MPI_COMM_WORLD, MPI_STATUS_IGNORE); /* check buffer */ for (j=0; j < i; j++) { int k; for (k=0; k < 129; k++) { if (k < 128 && buf[129*j + k] != (char) j) { if (verbose) fprintf(stderr, "(i=%d, pos=%d) should be %d but is %d\n", i, 129*j + k, j, (int) buf[129*j + k]); errs++; } else if (k == 128 && buf[129*j + k] != (char) 0) { if (verbose) fprintf(stderr, "(i=%d, pos=%d) should be %d but is %d\n", i, 129*j + k, 0, (int) buf[129*j + k]); errs++; } } } } MPI_Type_free(&newtype); } if (rank == 0) { int recv_errs = 0; MPI_Recv(&recv_errs, 1, MPI_INT, 1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE); if (recv_errs) { if (verbose) fprintf(stderr, "%d errors reported from receiver\n", recv_errs); errs += recv_errs; } } else if (rank == 1) { MPI_Send(&errs, 1, MPI_INT, 0, 0, MPI_COMM_WORLD); } fn_exit: free(buf); /* print message and exit */ if (errs) { if (rank == 0) fprintf(stderr, "Found %d errors\n", errs); } else { if (rank == 0) printf(" No Errors\n"); } MPI_Finalize(); return 0; } static int parse_args(int argc, char **argv) { /* int ret; while ((ret = getopt(argc, argv, "v")) >= 0) { switch (ret) { case 'v': verbose = 1; break; } } */ if (argc > 1 && strcmp(argv[1], "-v") == 0) verbose = 1; return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/rcancel.c000644 001750 001750 00000004350 12342443662 022005 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include "mpi.h" #include #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test of various receive cancel calls, with multiple requests to cancel"; */ int main( int argc, char *argv[] ) { int errs = 0; int rank, size, source, dest; MPI_Comm comm; MPI_Status status; MPI_Request req[4]; static int bufsizes[4] = { 1, 100, 10000, 1000000 }; char *bufs[4]; int flag, i; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); source = 0; dest = size - 1; if (rank == source) { MPI_Send( MPI_BOTTOM, 0, MPI_CHAR, dest, 1, MPI_COMM_WORLD ); } else if (rank == dest) { /* Create 3 requests to cancel, plus one to use. Then receive one message and exit */ for (i=0; i<4; i++) { bufs[i] = (char *) malloc( bufsizes[i] ); MPI_Irecv( bufs[i], bufsizes[i], MPI_CHAR, source, i, MPI_COMM_WORLD, &req[i] ); } /* Now, cancel them in a more interesting order, to ensure that the queue operation work properly */ MPI_Cancel( &req[2] ); MPI_Wait( &req[2], &status ); MTestPrintfMsg( 1, "Completed wait on irecv[2]\n" ); MPI_Test_cancelled( &status, &flag ); if (!flag) { errs ++; printf( "Failed to cancel a Irecv[2] request\n" ); fflush(stdout); } MPI_Cancel( &req[3] ); MPI_Wait( &req[3], &status ); MTestPrintfMsg( 1, "Completed wait on irecv[3]\n" ); MPI_Test_cancelled( &status, &flag ); if (!flag) { errs ++; printf( "Failed to cancel a Irecv[3] request\n" ); fflush(stdout); } MPI_Cancel( &req[0] ); MPI_Wait( &req[0], &status ); MTestPrintfMsg( 1, "Completed wait on irecv[0]\n" ); MPI_Test_cancelled( &status, &flag ); if (!flag) { errs ++; printf( "Failed to cancel a Irecv[0] request\n" ); fflush(stdout); } MPI_Wait( &req[1], &status ); MPI_Test_cancelled( &status, &flag ); if (flag) { errs ++; printf( "Incorrectly cancelled Irecv[1]\n" ); fflush(stdout); } } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/isendselfprobe.c000644 001750 001750 00000001664 12342443662 023407 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include "mpi.h" #include "mpitest.h" int main( int argc, char * argv[] ) { int rank; int sendMsg = 123; int recvMsg = 0; int flag = 0; int count; MPI_Status status; MPI_Request request; int errs = 0; MTest_Init( &argc, &argv ); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if(rank == 0) { MPI_Isend( &sendMsg, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &request ); while(!flag) { MPI_Iprobe( 0, 0, MPI_COMM_WORLD, &flag, &status ); } MPI_Get_count( &status, MPI_INT, &count ); if(count != 1) { errs++; } MPI_Recv( &recvMsg, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &status ); if(recvMsg != 123) { errs++; } MPI_Wait( &request, &status ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/isendself.c000644 001750 001750 00000003010 12342443662 022342 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include "mpi.h" #include "mpitest.h" int main( int argc, char *argv[] ) { int a[10], b[10], i; MPI_Status status; MPI_Request request; int rank, count; int errs = 0; MTest_Init( &argc, &argv ); MPI_Comm_rank(MPI_COMM_WORLD, &rank); for (i=0; i<10; i++) a[i] = i+1; status.MPI_ERROR = 0; MPI_Isend( a, 0, MPI_INT, rank, 0, MPI_COMM_WORLD, &request ); MPI_Recv( b, 1, MPI_INT, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status ); MPI_Get_count( &status, MPI_INT, &count ); if (status.MPI_SOURCE != rank || status.MPI_TAG != 0 || status.MPI_ERROR != 0 || count != 0) { errs++; printf ("1 status = %d %d %d %d\n", status.MPI_SOURCE, status.MPI_TAG, status.MPI_ERROR, count ); } /* printf( "b[0] = %d\n", b[0] );*/ MPI_Wait( &request, &status ); MPI_Isend( 0, 0, MPI_INT, rank, 0, MPI_COMM_WORLD, &request ); MPI_Recv( 0, 0, MPI_INT, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status ); MPI_Get_count( &status, MPI_INT, &count ); if (status.MPI_SOURCE != rank || status.MPI_TAG != 0 || status.MPI_ERROR != 0 || count != 0) { errs++; printf ("2 status = %d %d %d %d\n", status.MPI_SOURCE, status.MPI_TAG, status.MPI_ERROR, count ); } MPI_Wait( &request, &status ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/bsend4.c000644 001750 001750 00000002666 12342443662 021565 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include "mpi.h" #include "mpitest.h" #define BUFSIZE 2000 int main( int argc, char *argv[] ) { MPI_Status status; MPI_Request request; int a[10], b[10]; int buf[BUFSIZE], *bptr, bl, i, j, rank, size, errs=0; MTest_Init( 0, 0 ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); MPI_Buffer_attach( buf, BUFSIZE ); for (j=0; j<10; j++) { for (i=0; i<10; i++) { a[i] = (rank + 10 * j) * size + i; } MPI_Ibsend( a, 10, MPI_INT, 0, 27+j, MPI_COMM_WORLD, &request ); MPI_Wait( &request, &status ); } if (rank == 0) { for (i=0; i #include "mpitest.h" /* static char MTEST_Descrip[] = "Use of MPI_BOTTOM in communication"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int rank, size, source, dest, len, ii; MPI_Comm comm; MPI_Status status; MPI_Datatype newtype, oldtype; MPI_Aint disp; MTest_Init( &argc, &argv ); MPI_Get_address( &ii, &disp ); len = 1; oldtype = MPI_INT; MPI_Type_create_struct( 1, &len, &disp, &oldtype, &newtype ); MPI_Type_commit( &newtype ); comm = MPI_COMM_WORLD; MPI_Comm_size( comm, &size ); MPI_Comm_rank( comm, &rank ); if (size < 2) { errs++; fprintf( stderr, "This test requires at least two processes\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } source = 0; dest = 1; /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN ); if (rank == source) { ii = 2; err = MPI_Send( MPI_BOTTOM, 1, newtype, dest, 0, comm ); if (err) { errs++; MTestPrintError( err ); printf( "MPI_Send did not return MPI_SUCCESS\n" ); } } else if (rank == dest) { ii = -1; err = MPI_Recv( MPI_BOTTOM, 1, newtype, source, 0, comm, &status ); if (err) { MTestPrintError( err ); errs++; printf( "MPI_Recv did not return MPI_SUCCESS\n" ); } if (ii != 2) { errs++; printf( "Received %d but expected %d\n", ii, 2 ); } } MPI_Comm_set_errhandler( comm, MPI_ERRORS_ARE_FATAL ); MPI_Type_free( &newtype ); MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/bsendalign.c000644 001750 001750 00000003355 12342443662 022510 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * * (C) 2003 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include "mpi.h" #include "mpitest.h" /* Test bsend with a buffer with arbitrary alignment */ #define BUFSIZE 2000*4 int main( int argc, char *argv[] ) { MPI_Status status; int a[10], b[10]; int align; char buf[BUFSIZE+8], *bptr; int bl, i, j, rank, size; int errs = 0; MTest_Init( 0, 0 ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); for (align = 0; align < 7; align++) { MPI_Buffer_attach( buf+align, BUFSIZE); for (j=0; j<10; j++) { for (i=0; i<10; i++) { a[i] = (rank + 10 * j) * size + i; } MPI_Bsend( a, 10, MPI_INT, 0, 27+j, MPI_COMM_WORLD ); } if (rank == 0) { for (i=0; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Head to head send-recv to test backoff in device when large messages are being transferred"; */ #define MAX_NMSGS 100 int main( int argc, char *argv[] ) { int errs = 0; int rank, size, source, dest, partner; int i, testnum; double tsend; static int msgsizes[] = { 100, 1000, 10000, 100000, -1 }; static int nmsgs[] = { 100, 10, 10, 4 }; MPI_Comm comm; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); source = 0; dest = 1; if (size < 2) { printf( "This test requires at least 2 processes\n" ); MPI_Abort( MPI_COMM_WORLD, 1 ); exit(1); } for (testnum=0; msgsizes[testnum] > 0; testnum++) { if (rank == source || rank == dest) { int nmsg = nmsgs[testnum]; int msgSize = msgsizes[testnum]; MPI_Request r[MAX_NMSGS]; int *buf[MAX_NMSGS]; for (i=0; i 0.5) { printf( "Isends for %d messages of size %d took too long (%f seconds)\n", nmsg, msgSize, tsend ); errs++; } MTestPrintfMsg( 1, "%d Isends for size = %d took %f seconds\n", nmsg, msgSize, tsend ); for (i=0; i #include "mpitest.h" /* static char MTEST_Descrip[] = "Simple test of generalized requests"; */ int query_fn( void *extra_state, MPI_Status *status ); int query_fn( void *extra_state, MPI_Status *status ) { /* Set a default status */ status->MPI_SOURCE = MPI_UNDEFINED; status->MPI_TAG = MPI_UNDEFINED; MPI_Status_set_cancelled( status, 0 ); MPI_Status_set_elements( status, MPI_BYTE, 0 ); return 0; } int free_fn( void *extra_state ); int free_fn( void *extra_state ) { int *b = (int *)extra_state; if (b) *b = *b - 1; /* The value returned by the free function is the error code returned by the wait/test function */ return 0; } int cancel_fn( void *extra_state, int complete ); int cancel_fn( void *extra_state, int complete ) { return 0; } /* * This is a very simple test of generalized requests. Normally, the * MPI_Grequest_complete function would be called from another routine, * often running in a separate thread. This simple code allows us to * check that requests can be created, tested, and waited on in the * case where the request is complete before the wait is called. * * Note that MPI did *not* define a routine that can be called within * test or wait to advance the state of a generalized request. * Most uses of generalized requests will need to use a separate thread. */ int main( int argc, char *argv[] ) { int errs = 0; int counter, flag; MPI_Status status; MPI_Request request; MTest_Init( &argc, &argv ); MPI_Grequest_start( query_fn, free_fn, cancel_fn, NULL, &request ); MPI_Test( &request, &flag, &status ); if (flag) { errs++; fprintf( stderr, "Generalized request marked as complete\n" ); } MPI_Grequest_complete( request ); MPI_Wait( &request, &status ); counter = 1; MPI_Grequest_start( query_fn, free_fn, cancel_fn, &counter, &request ); MPI_Grequest_complete( request ); MPI_Wait( &request, MPI_STATUS_IGNORE ); if (counter) { errs++; fprintf( stderr, "Free routine not called, or not called with extra_data" ); } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/sendflood.c000644 001750 001750 00000010325 12342443662 022352 0ustar00cici000000 000000 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ /* * (C) 2008 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ #include #include #include #include "mpi.h" /* * Run this test with 8 processes. This test was submitted by xxx * as a result of problems seen with the ch3:shm device on a Solaris * system. The symptom is that the test hangs; this is due to losing * a message, probably due to a race condition in a message-queue update. * As a test for race conditions, it may need to be run multiple times * to expose a problem if a problem does exist. */ #define LOOP_COUNT 10000 #define DATA_SIZE 4 #define MP_TAG 999 #define PROGRESS_COUNT 0xfff static int verbose = 0; static int loopProgress = 0; int main( int argc, char *argv[] ) { int nProc, rank ; int i, j, status ; FILE *pf=0 ; MPI_Init( &argc, &argv ) ; MPI_Comm_size( MPI_COMM_WORLD, &nProc ) ; MPI_Comm_rank( MPI_COMM_WORLD, &rank ) ; for (i=1; i #include #include "mpitest.h" /* static char MTEST_Descrip[] = "Test of sending to self (with a preposted receive)"; */ int main( int argc, char *argv[] ) { int errs = 0, err; int rank, size; int count; MPI_Comm comm; MPI_Request req; MTestDatatype sendtype, recvtype; MTest_Init( &argc, &argv ); comm = MPI_COMM_WORLD; MPI_Comm_rank( comm, &rank ); MPI_Comm_size( comm, &size ); /* To improve reporting of problems about operations, we change the error handler to errors return */ MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN ); for (count = 1; count < 65000; count = count * 2) { while (MTestGetDatatypes( &sendtype, &recvtype, count )) { sendtype.InitBuf( &sendtype ); recvtype.InitBuf( &recvtype ); err = MPI_Irecv( recvtype.buf, recvtype.count, recvtype.datatype, rank, 0, comm, &req ); if (err) { errs++; if (errs < 10) { MTestPrintError( err ); } } err = MPI_Send( sendtype.buf, sendtype.count, sendtype.datatype, rank, 0, comm); if (err) { errs++; if (errs < 10) { MTestPrintError( err ); } } err = MPI_Wait( &req, MPI_STATUS_IGNORE ); err = MTestCheckRecv( 0, &recvtype ); if (err) { if (errs < 10) { printf( "Data in target buffer did not match for destination datatype %s and source datatype %s, count = %d\n", MTestGetDatatypeName( &recvtype ), MTestGetDatatypeName( &sendtype ), count ); recvtype.printErrors = 1; (void)MTestCheckRecv( 0, &recvtype ); } errs += err; } err = MPI_Irecv( recvtype.buf, recvtype.count, recvtype.datatype, rank, 0, comm, &req ); if (err) { errs++; if (errs < 10) { MTestPrintError( err ); } } err = MPI_Ssend( sendtype.buf, sendtype.count, sendtype.datatype, rank, 0, comm); if (err) { errs++; if (errs < 10) { MTestPrintError( err ); } } err = MPI_Wait( &req, MPI_STATUS_IGNORE ); err = MTestCheckRecv( 0, &recvtype ); if (err) { if (errs < 10) { printf( "Data in target buffer did not match for destination datatype %s and source datatype %s, count = %d\n", MTestGetDatatypeName( &recvtype ), MTestGetDatatypeName( &sendtype ), count ); recvtype.printErrors = 1; (void)MTestCheckRecv( 0, &recvtype ); } errs += err; } err = MPI_Irecv( recvtype.buf, recvtype.count, recvtype.datatype, rank, 0, comm, &req ); if (err) { errs++; if (errs < 10) { MTestPrintError( err ); } } err = MPI_Rsend( sendtype.buf, sendtype.count, sendtype.datatype, rank, 0, comm); if (err) { errs++; if (errs < 10) { MTestPrintError( err ); } } err = MPI_Wait( &req, MPI_STATUS_IGNORE ); err = MTestCheckRecv( 0, &recvtype ); if (err) { if (errs < 10) { printf( "Data in target buffer did not match for destination datatype %s and source datatype %s, count = %d\n", MTestGetDatatypeName( &recvtype ), MTestGetDatatypeName( &sendtype ), count ); recvtype.printErrors = 1; (void)MTestCheckRecv( 0, &recvtype ); } errs += err; } MTestFreeDatatype( &sendtype ); MTestFreeDatatype( &recvtype ); } } MTest_Finalize( errs ); MPI_Finalize(); return 0; } SimGrid-3.11/teshsuite/smpi/mpich3-test/pt2pt/CMakeLists.txt000644 001750 001750 00000012711 12342443654 022773 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi AND enable_smpi_MPICH3_testsuite) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") set(CMAKE_Fortran_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include/") add_executable(anyall anyall.c) add_executable(bottom bottom.c) # add_executable(bsend1 bsend1.c) # add_executable(bsend2 bsend2.c) # add_executable(bsend3 bsend3.c) # add_executable(bsend4 bsend4.c) # add_executable(bsend5 bsend5.c) # add_executable(bsendalign bsendalign.c) # add_executable(bsendfrag bsendfrag.c) # add_executable(bsendpending bsendpending.c) # add_executable(cancelrecv cancelrecv.c) add_executable(eagerdt eagerdt.c) # add_executable(greq1 greq1.c) # add_executable(icsend icsend.c) add_executable(inactivereq inactivereq.c) add_executable(isendself isendself.c) add_executable(isendselfprobe isendselfprobe.c) # add_executable(large_message large_message.c) add_executable(mprobe mprobe.c) # add_executable(pingping pingping.c) add_executable(probenull probenull.c) add_executable(probe-unexp probe-unexp.c) # add_executable(pscancel pscancel.c) # add_executable(rcancel rcancel.c) # add_executable(rqfreeb rqfreeb.c) # add_executable(rqstatus rqstatus.c) # add_executable(scancel2 scancel2.c) # add_executable(scancel scancel.c) add_executable(sendall sendall.c) add_executable(sendflood sendflood.c) # add_executable(sendrecv1 sendrecv1.c) add_executable(sendrecv2 sendrecv2.c) add_executable(sendrecv3 sendrecv3.c) # add_executable(sendself sendself.c) add_executable(waitany-null waitany-null.c) add_executable(waittestnull waittestnull.c) target_link_libraries(anyall simgrid mtest_c) target_link_libraries(bottom simgrid mtest_c) # target_link_libraries(bsend1 simgrid mtest_c) # target_link_libraries(bsend2 simgrid mtest_c) # target_link_libraries(bsend3 simgrid mtest_c) # target_link_libraries(bsend4 simgrid mtest_c) # target_link_libraries(bsend5 simgrid mtest_c) # target_link_libraries(bsendalign simgrid mtest_c) # target_link_libraries(bsendfrag simgrid mtest_c) # target_link_libraries(bsendpending simgrid mtest_c) # target_link_libraries(cancelrecv simgrid mtest_c) target_link_libraries(eagerdt simgrid mtest_c) # target_link_libraries(greq1 simgrid mtest_c) # target_link_libraries(icsend simgrid mtest_c) target_link_libraries(inactivereq simgrid mtest_c) target_link_libraries(isendself simgrid mtest_c) target_link_libraries(isendselfprobe simgrid mtest_c) # target_link_libraries(large_message simgrid mtest_c) target_link_libraries(mprobe simgrid mtest_c) # target_link_libraries(pingping simgrid mtest_c) target_link_libraries(probenull simgrid mtest_c) target_link_libraries(probe-unexp simgrid mtest_c) # target_link_libraries(pscancel simgrid mtest_c) # target_link_libraries(rcancel simgrid mtest_c) # target_link_libraries(rqfreeb simgrid mtest_c) # target_link_libraries(rqstatus simgrid mtest_c) # target_link_libraries(scancel2 simgrid mtest_c) # target_link_libraries(scancel simgrid mtest_c) target_link_libraries(sendall simgrid mtest_c) target_link_libraries(sendflood simgrid mtest_c) # target_link_libraries(sendrecv1 simgrid mtest_c) target_link_libraries(sendrecv2 simgrid mtest_c) target_link_libraries(sendrecv3 simgrid mtest_c) # target_link_libraries(sendself simgrid mtest_c) target_link_libraries(waitany-null simgrid mtest_c) target_link_libraries(waittestnull simgrid mtest_c) endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/anyall.c ${CMAKE_CURRENT_SOURCE_DIR}/bottom.c ${CMAKE_CURRENT_SOURCE_DIR}/bsend1.c ${CMAKE_CURRENT_SOURCE_DIR}/bsend2.c ${CMAKE_CURRENT_SOURCE_DIR}/bsend3.c ${CMAKE_CURRENT_SOURCE_DIR}/bsend4.c ${CMAKE_CURRENT_SOURCE_DIR}/bsend5.c ${CMAKE_CURRENT_SOURCE_DIR}/bsendalign.c ${CMAKE_CURRENT_SOURCE_DIR}/bsendfrag.c ${CMAKE_CURRENT_SOURCE_DIR}/bsendpending.c ${CMAKE_CURRENT_SOURCE_DIR}/cancelrecv.c ${CMAKE_CURRENT_SOURCE_DIR}/eagerdt.c ${CMAKE_CURRENT_SOURCE_DIR}/greq1.c ${CMAKE_CURRENT_SOURCE_DIR}/icsend.c ${CMAKE_CURRENT_SOURCE_DIR}/inactivereq.c ${CMAKE_CURRENT_SOURCE_DIR}/isendself.c ${CMAKE_CURRENT_SOURCE_DIR}/isendselfprobe.c ${CMAKE_CURRENT_SOURCE_DIR}/large_message.c ${CMAKE_CURRENT_SOURCE_DIR}/mprobe.c ${CMAKE_CURRENT_SOURCE_DIR}/pingping.c ${CMAKE_CURRENT_SOURCE_DIR}/probenull.c ${CMAKE_CURRENT_SOURCE_DIR}/probe-unexp.c ${CMAKE_CURRENT_SOURCE_DIR}/pscancel.c ${CMAKE_CURRENT_SOURCE_DIR}/rcancel.c ${CMAKE_CURRENT_SOURCE_DIR}/rqfreeb.c ${CMAKE_CURRENT_SOURCE_DIR}/rqstatus.c ${CMAKE_CURRENT_SOURCE_DIR}/scancel2.c ${CMAKE_CURRENT_SOURCE_DIR}/scancel.c ${CMAKE_CURRENT_SOURCE_DIR}/sendall.c ${CMAKE_CURRENT_SOURCE_DIR}/sendflood.c ${CMAKE_CURRENT_SOURCE_DIR}/sendrecv1.c ${CMAKE_CURRENT_SOURCE_DIR}/sendrecv2.c ${CMAKE_CURRENT_SOURCE_DIR}/sendrecv3.c ${CMAKE_CURRENT_SOURCE_DIR}/sendself.c ${CMAKE_CURRENT_SOURCE_DIR}/waitany-null.c ${CMAKE_CURRENT_SOURCE_DIR}/waittestnull.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/testlist PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/mpich3-test/CMakeLists.txt000644 001750 001750 00000003637 12342443654 021731 0ustar00cici000000 000000 set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) #set(stdo_std_smpi # ${CMAKE_CURRENT_SOURCE_DIR}/topol/cartmap.std # ${CMAKE_CURRENT_SOURCE_DIR}/topol/graphtest.std # ${CMAKE_CURRENT_SOURCE_DIR}/topol/cartf.std #) if("${CMAKE_BINARY_DIR}" STREQUAL "${CMAKE_HOME_DIRECTORY}") else() foreach(srcfile ${stdo_std_smpi}) set(dstfile ${srcfile}) string(REPLACE "${CMAKE_HOME_DIRECTORY}" "${CMAKE_BINARY_DIR}" dstfile "${dstfile}") #message("copy ${srcfile} to ${dstfile}") configure_file("${srcfile}" "${dstfile}" COPYONLY) endforeach() endif() set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/README ${CMAKE_CURRENT_SOURCE_DIR}/runtests ${CMAKE_CURRENT_SOURCE_DIR}/testlist ${CMAKE_CURRENT_SOURCE_DIR}/hostfile ${CMAKE_CURRENT_SOURCE_DIR}/checktests ${CMAKE_CURRENT_SOURCE_DIR}/util/mtest.c ${CMAKE_CURRENT_SOURCE_DIR}/util/mtest_manual.c ${CMAKE_CURRENT_SOURCE_DIR}/f77/testlist ${CMAKE_CURRENT_SOURCE_DIR}/f90/testlist ${CMAKE_CURRENT_SOURCE_DIR}/include/mpitestconf.h ${CMAKE_CURRENT_SOURCE_DIR}/include/mpitest.h PARENT_SCOPE) #build only once files used in each test (C version compiled here at root, F77 is in f77/util, and F90 in F90/util) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include/") #C version - use automatic privatization if mmap is supported, manual through SMPI macros if not if(HAVE_MMAP) add_library(mtest_c STATIC util/mtest.c) else() add_library(mtest_c STATIC util/mtest_manual.c) endif() SimGrid-3.11/teshsuite/smpi/allgather/000755 001750 001750 00000000000 12342443665 016765 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/smpi/allgather/allgather_coll.tesh000644 001750 001750 00000005466 12342443665 022641 0ustar00cici000000 000000 # Smpi Alltoall collectives tests ! setenv LD_LIBRARY_PATH=../../lib ! output sort p Test all to all $ ${bindir:=.}/../../../bin/smpirun -map -hostfile ../hostfile -platform ../../../examples/msg/small_platform.xml -np 16 --log=xbt_cfg.thres:critical ${bindir:=.}/allgather_coll --log=smpi_kernel.thres:warning > You requested to use 16 processes, but there is only 5 processes in your hostfile... > [rank 0] -> Tremblay > [rank 1] -> Jupiter > [rank 2] -> Fafard > [rank 3] -> Ginette > [rank 4] -> Bourassa > [rank 5] -> Tremblay > [rank 6] -> Jupiter > [rank 7] -> Fafard > [rank 8] -> Ginette > [rank 9] -> Bourassa > [rank 10] -> Tremblay > [rank 11] -> Jupiter > [rank 12] -> Fafard > [rank 13] -> Ginette > [rank 14] -> Bourassa > [rank 15] -> Tremblay > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) > [0] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [1] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [2] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [3] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [4] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [5] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [6] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [7] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [8] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [9] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [10] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [11] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [12] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [13] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [14] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [15] rcvbuf=[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ] > [0] sndbuf=[0 1 ] > [1] sndbuf=[2 3 ] > [2] sndbuf=[4 5 ] > [3] sndbuf=[6 7 ] > [4] sndbuf=[8 9 ] > [5] sndbuf=[10 11 ] > [6] sndbuf=[12 13 ] > [7] sndbuf=[14 15 ] > [8] sndbuf=[16 17 ] > [9] sndbuf=[18 19 ] > [10] sndbuf=[20 21 ] > [11] sndbuf=[22 23 ] > [12] sndbuf=[24 25 ] > [13] sndbuf=[26 27 ] > [14] sndbuf=[28 29 ] > [15] sndbuf=[30 31 ] SimGrid-3.11/teshsuite/smpi/allgather/allgather_coll.c000644 001750 001750 00000002606 12342443660 022104 0ustar00cici000000 000000 /* Copyright (c) 2009-2010, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include #include #include "mpi.h" #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #define EXIT_FAILURE 1 #endif int main(int argc, char *argv[]) { int rank, size; int i; int *sb; int *rb; int status; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); int count = 2; sb = (int *) xbt_malloc(count * sizeof(int)); rb = (int *) xbt_malloc(count * size * sizeof(int)); for (i = 0; i < count; ++i) sb[i] = rank * count + i; for (i = 0; i < count * size; ++i) rb[i] = 0; printf("[%d] sndbuf=[", rank); for (i = 0; i < count; i++) printf("%d ", sb[i]); printf("]\n"); status = MPI_Allgather(sb, count, MPI_INT, rb, count, MPI_INT, MPI_COMM_WORLD); printf("[%d] rcvbuf=[", rank); for (i = 0; i < count * size; i++) printf("%d ", rb[i]); printf("]\n"); if (rank == 0) { if (status != MPI_SUCCESS) { printf("allgather returned %d\n", status); fflush(stdout); } } free(sb); free(rb); MPI_Finalize(); return (EXIT_SUCCESS); } SimGrid-3.11/teshsuite/smpi/allgather/CMakeLists.txt000644 001750 001750 00000001460 12342443654 021524 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") include_directories("${CMAKE_HOME_DIRECTORY}/include/smpi") add_executable(allgather_coll allgather_coll.c) target_link_libraries(allgather_coll simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/allgather_coll.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/allgather_coll.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/smpi/CMakeLists.txt000644 001750 001750 00000001124 12342443654 017556 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(enable_smpi) if(WIN32) set(CMAKE_C_FLAGS "-include ${CMAKE_HOME_DIRECTORY}/include/smpi/smpi_main.h") else() set(CMAKE_C_COMPILER "${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc") endif() set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") endif() set(tesh_files ${tesh_files} PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(examples_src ${examples_src} PARENT_SCOPE ) set(bin_files ${bin_files} ${CMAKE_CURRENT_SOURCE_DIR}/hostfile PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/simix/000755 001750 001750 00000000000 12342443654 015201 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/simix/check_defaults/000755 001750 001750 00000000000 12342443665 020147 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/simix/check_defaults/factory_thread.tesh000644 001750 001750 00000000132 12342443665 024026 0ustar00cici000000 000000 $ ${bindir:=.}/check_defaults > [simix_context/VERBOSE] Activating thread context factory SimGrid-3.11/teshsuite/simix/check_defaults/factory_ucontext.tesh000644 001750 001750 00000000130 12342443665 024426 0ustar00cici000000 000000 $ ${bindir:=.}/check_defaults > [simix_context/VERBOSE] Activating SYSV context factory SimGrid-3.11/teshsuite/simix/check_defaults/check_defaults.c000644 001750 001750 00000001130 12342443665 023252 0ustar00cici000000 000000 /* check_defaults -- simple program displaying its context factory */ /* Copyright (c) 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "simgrid/simix.h" #include "xbt/log.h" int main(int argc, char *argv[]) { xbt_log_control_set("root.fmt:[%c/%p]%e%m%n"); xbt_log_control_set("simix_context.threshold:verbose"); SIMIX_global_init(&argc, argv); return 0; } SimGrid-3.11/teshsuite/simix/check_defaults/factory_raw.tesh000644 001750 001750 00000000176 12342443665 023360 0ustar00cici000000 000000 $ ${bindir:=.}/check_defaults > [simix_context/VERBOSE] Using raw contexts. Because the glibc is just not good enough for us. SimGrid-3.11/teshsuite/simix/check_defaults/CMakeLists.txt000644 001750 001750 00000001175 12342443654 022711 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(check_defaults check_defaults.c) target_link_libraries(check_defaults simgrid) set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/factory_raw.tesh ${CMAKE_CURRENT_SOURCE_DIR}/factory_thread.tesh ${CMAKE_CURRENT_SOURCE_DIR}/factory_ucontext.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/check_defaults.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/simix/stack_overflow/000755 001750 001750 00000000000 12342443670 020227 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/simix/stack_overflow/stack_overflow.xml000644 001750 001750 00000000533 12342443670 024002 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simix/stack_overflow/stack_overflow.c000644 001750 001750 00000002501 12342443665 023425 0ustar00cici000000 000000 /* stack_overflow -- simple program generating a stack overflow */ /* Copyright (c) 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include "simgrid/platf.h" #include "simgrid/simix.h" #include "surf/surfxml_parse.h" #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_CATEGORY(test, "my log messages"); static unsigned collatz(unsigned c0, unsigned n) { unsigned x; if (n == 0) { x = c0; } else { x = collatz(c0, n - 1); if (x % 2 == 0) x = x / 2; else x = 3 * x + 1; } return x; } static int master(int argc, char *argv[]) { XBT_INFO("Launching our nice bugged recursive function..."); unsigned i = 1; do { i *= 2; unsigned res = collatz(i, i); XBT_VERB("collatz(%u, %u) returned %u", i, i, res); } while (i <= 0x80000000u); return 0; } int main(int argc, char *argv[]) { SIMIX_global_init(&argc, argv); if (argc != 2) { printf("Usage: %s platform_and_deployment.xml\n", argv[0]); exit(EXIT_FAILURE); } SIMIX_function_register("master", master); SIMIX_create_environment(argv[1]); SIMIX_launch_application(argv[1]); SIMIX_run(); return 0; } SimGrid-3.11/teshsuite/simix/stack_overflow/stack_overflow.tesh000644 001750 001750 00000001204 12342443665 024145 0ustar00cici000000 000000 ! expect signal SIGSEGV $ ${bindir:=.}/stack_overflow --cfg=contexts/stack_size:96 stack_overflow.xml > [Tremblay:master:(0) 0.000000] [test/INFO] Launching our nice bugged recursive function... > Access violation detected. > This can result from a programming error in your code or, although less likely, > from a bug in SimGrid itself. This can also be the sign of a bug in the OS or > in third-party libraries. Failing hardware can sometimes generate such errors > too. > Finally, if nothing of the above applies, this can result from a stack overflow. > Try to increase stack size with --cfg=contexts/stack_size (current size is 96 KiB). SimGrid-3.11/teshsuite/simix/stack_overflow/CMakeLists.txt000644 001750 001750 00000001113 12342443654 022765 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(stack_overflow stack_overflow.c) target_link_libraries(stack_overflow simgrid) set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/stack_overflow.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/stack_overflow.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/stack_overflow.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/simdag/000755 001750 001750 00000000000 12342443654 015314 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/basic/000755 001750 001750 00000000000 12342443670 016373 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/basic/basic2.c000644 001750 001750 00000004265 12342443665 017715 0ustar00cici000000 000000 /* Copyright (c) 2007-2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(basic2, sd, "SimDag test basic2"); /* Basic SimDag Test 2 * Scenario: * - Create a no-op Init task * - Create two communication tasks: 1GB and 100MB * - Schedule them concurrently on the two hosts of the platform * The two communications occur simultaneously. They share the network for the * duration of the shortest one, then the longest one has the full bandwidth. * Simulated time should be: * 1e8/(1/2*1.25e8) + 9e8/1.25e8) + 1e-4 = 8.8001 seconds */ int main(int argc, char **argv) { SD_task_t taskInit; SD_task_t taskA; SD_task_t taskB; xbt_dynar_t ret; const SD_workstation_t *workstation; double communication_amount1 = 1e9; double communication_amount2 = 1e8; double no_cost = 0.0; /* initialization of SD */ SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); /* creation of the tasks and their dependencies */ taskInit = SD_task_create("Init", NULL, 1.0); taskA = SD_task_create("Task Comm A", NULL, 1.0); taskB = SD_task_create("Task Comm B", NULL, 1.0); /* scheduling parameters */ workstation = SD_workstation_get_list(); /* let's launch the simulation! */ SD_task_schedule(taskInit, 1, SD_workstation_get_list(), &no_cost, &no_cost, -1.0); SD_task_schedule(taskA, 1, &workstation[0], &no_cost, &communication_amount1, -1.0); SD_task_schedule(taskB, 1, &workstation[1], &no_cost, &communication_amount2, -1.0); SD_task_dependency_add(NULL, NULL, taskInit, taskA); SD_task_dependency_add(NULL, NULL, taskInit, taskB); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); SD_task_destroy(taskA); SD_task_destroy(taskB); SD_task_destroy(taskInit); XBT_INFO("Simulation time: %f", SD_get_clock()); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/basic/basic4.tesh000644 001750 001750 00000001005 12342443664 020424 0ustar00cici000000 000000 $ ${bindir:=.}/basic4 basic_platform.xml "--log=root.fmt:[%10.6r]%e%m%n" --log=sd_kernel.thresh:verbose > [ 0.000000] surf_workstation_model_init_ptask_L07 > [ 0.000000] Starting simulation... > [ 0.000000] Run simulation for -1.000000 seconds > [ 0.000000] Executing task 'Task Init' > [ 0.000000] Task 'Task Init' done > [ 0.000000] Executing task 'Task A' > [ 0.000100] Task 'Task A' done > [ 0.000100] Executing task 'Task Fin' > [ 0.000100] Task 'Task Fin' done > [ 0.000100] Simulation time: 0.000100 SimGrid-3.11/teshsuite/simdag/basic/basic4.c000644 001750 001750 00000003733 12342443665 017716 0ustar00cici000000 000000 /* Copyright (c) 2007-2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(basic4, sd, "SimDag test basic4"); /* Basic SimDag Test 4 * Scenario: * - Create a chain of tasks (Init, A, Fin) * - Have a 1B communication between two no-op tasks. * Verify that the tasks are actually simulated in the right order. * The simulated time should be equal to the network latency: 0.0001 seconds. */ int main(int argc, char **argv) { /* creation of the tasks and their dependencies */ SD_task_t taskInit; SD_task_t taskA; SD_task_t taskFin; xbt_dynar_t ret; /* scheduling parameters */ double no_cost[] = { 0., 0., 0., 0. }; double amount[] = { 0., 1., 0., 0. }; /* initialisation of SD */ SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); /* creation of the tasks and their dependencies */ taskInit = SD_task_create("Task Init", NULL, 1.0); taskA = SD_task_create("Task A", NULL, 1.0); taskFin = SD_task_create("Task Fin", NULL, 1.0); /* let's launch the simulation! */ SD_task_schedule(taskInit, 1, SD_workstation_get_list(), no_cost, no_cost, -1.0); SD_task_schedule(taskA, 2, SD_workstation_get_list(), no_cost, amount, -1.0); SD_task_schedule(taskFin, 1, SD_workstation_get_list(), no_cost, no_cost, -1.0); SD_task_dependency_add(NULL, NULL, taskInit, taskA); SD_task_dependency_add(NULL, NULL, taskA, taskFin); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); SD_task_destroy(taskInit); SD_task_destroy(taskA); SD_task_destroy(taskFin); XBT_INFO("Simulation time: %f", SD_get_clock()); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/basic/basic3.tesh000644 001750 001750 00000001005 12342443664 020423 0ustar00cici000000 000000 $ ${bindir:=.}/basic3 basic_platform.xml "--log=root.fmt:[%10.6r]%e%m%n" --log=sd_kernel.thresh:verbose > [ 0.000000] surf_workstation_model_init_ptask_L07 > [ 0.000000] Starting simulation... > [ 0.000000] Run simulation for -1.000000 seconds > [ 0.000000] Executing task 'Task Init' > [ 0.000000] Task 'Task Init' done > [ 0.000000] Executing task 'Task A' > [ 0.000000] Task 'Task A' done > [ 0.000000] Executing task 'Task Fin' > [ 0.000000] Task 'Task Fin' done > [ 0.000000] Simulation time: 0.000000 SimGrid-3.11/teshsuite/simdag/basic/basic6.tesh000644 001750 001750 00000000267 12342443664 020437 0ustar00cici000000 000000 $ ${bindir:=.}/basic6 ../network/p2p/platform_2p_1sl.xml "--log=root.fmt:[%10.6r]%e%m%n" > [ 0.000000] surf_workstation_model_init_ptask_L07 > [ 2.000000] Simulation time: 2.000000 SimGrid-3.11/teshsuite/simdag/basic/basic1.c000644 001750 001750 00000004176 12342443665 017715 0ustar00cici000000 000000 /* Copyright (c) 2007-2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(basic1, sd, "SimDag test basic1"); /* Basic SimDag Test 1 * Scenario: * - Create a no-op Init task * - Create two communication tasks: 1GB and 1GB * - Schedule them concurrently on the two hosts of the platform * The two communications occur simultaneously. They share the network for the * whole duration of the simulation. * Simulated time should be: * 1e9/(1/2*1.25e8) + 1e-4 = 16.0001 seconds */ int main(int argc, char **argv) { SD_task_t taskInit; SD_task_t taskA; SD_task_t taskB; xbt_dynar_t ret; double communication_amount1 = 1e9; double communication_amount2 = 1e9; double no_cost = 0.0; const SD_workstation_t *workstation; /* initialization of SD */ SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); /* creation of the tasks and their dependencies */ taskInit = SD_task_create("Init", NULL, 1.0); taskA = SD_task_create("Task Comm A", NULL, 1.0); taskB = SD_task_create("Task Comm B", NULL, 1.0); /* scheduling parameters */ workstation = SD_workstation_get_list(); /* let's launch the simulation! */ SD_task_schedule(taskInit, 1, SD_workstation_get_list(), &no_cost, &no_cost, -1.0); SD_task_schedule(taskA, 1, &workstation[0], &no_cost, &communication_amount1, -1.0); SD_task_schedule(taskB, 1, &workstation[1], &no_cost, &communication_amount2, -1.0); SD_task_dependency_add(NULL, NULL, taskInit, taskA); SD_task_dependency_add(NULL, NULL, taskInit, taskB); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); SD_task_destroy(taskA); SD_task_destroy(taskB); SD_task_destroy(taskInit); XBT_INFO("Simulation time: %f", SD_get_clock()); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/basic/basic6.c000644 001750 001750 00000003156 12342443665 017717 0ustar00cici000000 000000 /* Copyright (c) 2007-2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" #include "xbt/asserts.h" #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(basic6, sd, "SimDag test basic6"); /* test scheduling 2 tasks at the same time without artificial dependencies */ /* Basic SimDag Test 6 * Scenario: * - Schedule two parallel tasks concurrently on a P2P platform * - Hosts computes 1B per second * Computing power is shared between tasks. * Simulated time should be: * 1/(1/2) = 2 seconds */ int main(int argc, char **argv) { double comm_cost[] = { 0.0, 0.0, 0.0, 0.0 }; double comp_cost[] = { 1.0 }; SD_task_t taskA, taskB; xbt_dynar_t ret; SD_init(&argc, argv); SD_create_environment(argv[1]); taskA = SD_task_create("Task A", NULL, 1.0); taskB = SD_task_create("Task B", NULL, 1.0); SD_task_schedule(taskA, 1, SD_workstation_get_list(), comp_cost, comm_cost, -1.0); SD_task_schedule(taskB, 1, SD_workstation_get_list(), comp_cost, comm_cost, -1.0); ret = SD_simulate(-1.0); xbt_assert(xbt_dynar_length(ret) == 2, "I was expecting the terminaison of 2 tasks, but I got %lu instead", xbt_dynar_length(ret)); xbt_dynar_free(&ret); SD_task_destroy(taskA); SD_task_destroy(taskB); XBT_INFO("Simulation time: %f", SD_get_clock()); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/basic/basic0.tesh000644 001750 001750 00000000247 12342443664 020427 0ustar00cici000000 000000 $ ${bindir:=.}/basic0 basic_platform.xml "--log=root.fmt:[%10.6r]%e%m%n" > [ 0.000000] surf_workstation_model_init_ptask_L07 > [ 0.800100] Simulation time: 0.800100 SimGrid-3.11/teshsuite/simdag/basic/basic5.c000644 001750 001750 00000004056 12342443665 017716 0ustar00cici000000 000000 /* Copyright (c) 2007-2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(basic5, sd, "SimDag test basic5"); /* Basic SimDag Test 5 * Scenario: * - Create a no-op Init task * - Create two tasks: send 100kB and compute 10Mflops * - Schedule them concurrently * The two tasks should overlap smoothly as they use different resources. * Simulated time should be: * MAX(1e5/(1.25e8), 1e7/4e9) = MAX(.0009, .0025) = 0.0025 seconds */ int main(int argc, char **argv) { /* creation of the tasks and their dependencies */ SD_task_t taskInit; SD_task_t taskA; SD_task_t taskB; xbt_dynar_t ret; /* scheduling parameters */ double no_cost[] = { 0., 0., 0., 0. }; double amount[] = { 0., 100000., 0., 0. }; double comput[] = { 10000000. }; /* initialization of SD */ SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); /* creation of the tasks and their dependencies */ taskInit = SD_task_create("Task Init", NULL, 1.0); taskA = SD_task_create("Task A", NULL, 1.0); taskB = SD_task_create("Task B", NULL, 1.0); /* let's launch the simulation! */ SD_task_schedule(taskInit, 1, SD_workstation_get_list(), no_cost, no_cost, -1.0); SD_task_schedule(taskA, 2, SD_workstation_get_list(), no_cost, amount, -1.0); SD_task_schedule(taskB, 1, SD_workstation_get_list(), comput, no_cost, -1.0); SD_task_dependency_add(NULL, NULL, taskInit, taskA); SD_task_dependency_add(NULL, NULL, taskInit, taskB); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); SD_task_destroy(taskInit); SD_task_destroy(taskA); SD_task_destroy(taskB); XBT_INFO("Simulation time: %f", SD_get_clock()); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/basic/basic_platform.xml000644 001750 001750 00000001036 12342443670 022102 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/basic/basic0.c000644 001750 001750 00000004264 12342443665 017712 0ustar00cici000000 000000 /* Copyright (c) 2007-2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(basic0, sd, "SimDag test basic0"); /* Basic SimDag Test 0 * Scenario: * - Create a no-op Init task * - Create two communication tasks: 100MB and 1B * - Schedule them concurrently on the two hosts of the platform * The two communications occur simultaneously but one is so short that it has * no impact on the other. * Simulated time should be: * 1e8/1.25e8 + 1e-4 = 0.8001 seconds * This corresponds to paying latency once and having the full bandwidth for the * big message. */ int main(int argc, char **argv) { SD_task_t taskInit; SD_task_t taskA; SD_task_t taskB; xbt_dynar_t ret; /* scheduling parameters */ double communication_amount1[] = { 0, 1e8, 0, 0 }; double communication_amount2[] = { 0, 1, 0, 0 }; const double no_cost[] = { 0.0, 0.0 }; /* initialization of SD */ SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); /* creation of the tasks and their dependencies */ taskInit = SD_task_create("Init", NULL, 1.0); taskA = SD_task_create("Task Comm 1", NULL, 1.0); taskB = SD_task_create("Task Comm 2", NULL, 1.0); /* let's launch the simulation! */ SD_task_schedule(taskInit, 1, SD_workstation_get_list(), no_cost, no_cost, -1.0); SD_task_schedule(taskA, 2, SD_workstation_get_list(), no_cost, communication_amount1, -1.0); SD_task_schedule(taskB, 2, SD_workstation_get_list(), no_cost, communication_amount2, -1.0); SD_task_dependency_add(NULL, NULL, taskInit, taskA); SD_task_dependency_add(NULL, NULL, taskInit, taskB); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); SD_task_destroy(taskInit); SD_task_destroy(taskA); SD_task_destroy(taskB); XBT_INFO("Simulation time: %f", SD_get_clock()); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/basic/basic2.tesh000644 001750 001750 00000000277 12342443664 020434 0ustar00cici000000 000000 $ ${bindir:=.}/basic2 basic_platform.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > [ 8.800100] (0:@) Simulation time: 8.800100 SimGrid-3.11/teshsuite/simdag/basic/basic3.c000644 001750 001750 00000003374 12342443665 017716 0ustar00cici000000 000000 /* Copyright (c) 2007-2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(basic3, sd, "SimDag test basic3"); /* Basic SimDag Test 3 * Scenario: * - Create a chain of tasks (Init, A, Fin) * Verify that the tasks are actually simulated in the right order. */ int main(int argc, char **argv) { SD_task_t taskInit; SD_task_t taskA; SD_task_t taskFin; xbt_dynar_t ret; /* scheduling parameters */ double no_cost[] = { 0.0, 0.0, 0.0, 0.0 }; /* initialization of SD */ SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); /* creation of the tasks and their dependencies */ taskInit = SD_task_create("Task Init", NULL, 1.0); taskA = SD_task_create("Task A", NULL, 1.0); taskFin = SD_task_create("Task Fin", NULL, 1.0); /* let's launch the simulation! */ SD_task_schedule(taskInit, 1, SD_workstation_get_list(), no_cost, no_cost, -1.0); SD_task_schedule(taskA, 2, SD_workstation_get_list(), no_cost, no_cost, -1.0); SD_task_schedule(taskFin, 1, SD_workstation_get_list(), no_cost, no_cost, -1.0); SD_task_dependency_add(NULL, NULL, taskInit, taskA); SD_task_dependency_add(NULL, NULL, taskA, taskFin); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); SD_task_destroy(taskInit); SD_task_destroy(taskA); SD_task_destroy(taskFin); XBT_INFO("Simulation time: %f", SD_get_clock()); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/basic/basic1.tesh000644 001750 001750 00000000300 12342443664 020416 0ustar00cici000000 000000 $ ${bindir:=.}/basic1 basic_platform.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > [ 16.000100] (0:@) Simulation time: 16.000100 SimGrid-3.11/teshsuite/simdag/basic/basic5.tesh000644 001750 001750 00000000247 12342443664 020434 0ustar00cici000000 000000 $ ${bindir:=.}/basic5 basic_platform.xml "--log=root.fmt:[%10.6r]%e%m%n" > [ 0.000000] surf_workstation_model_init_ptask_L07 > [ 0.002500] Simulation time: 0.002500 SimGrid-3.11/teshsuite/simdag/basic/CMakeLists.txt000644 001750 001750 00000003536 12342443654 021144 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(basic0 basic0.c) add_executable(basic1 basic1.c) add_executable(basic2 basic2.c) add_executable(basic3 basic3.c) add_executable(basic4 basic4.c) add_executable(basic5 basic5.c) add_executable(basic6 basic6.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(basic0 simgrid m pthread ) target_link_libraries(basic1 simgrid m pthread ) target_link_libraries(basic2 simgrid m pthread ) target_link_libraries(basic3 simgrid m pthread ) target_link_libraries(basic4 simgrid m pthread ) target_link_libraries(basic5 simgrid m pthread ) target_link_libraries(basic6 simgrid m pthread ) else() target_link_libraries(basic0 simgrid) target_link_libraries(basic1 simgrid) target_link_libraries(basic2 simgrid) target_link_libraries(basic3 simgrid) target_link_libraries(basic4 simgrid) target_link_libraries(basic5 simgrid) target_link_libraries(basic6 simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/basic0.tesh ${CMAKE_CURRENT_SOURCE_DIR}/basic1.tesh ${CMAKE_CURRENT_SOURCE_DIR}/basic2.tesh ${CMAKE_CURRENT_SOURCE_DIR}/basic3.tesh ${CMAKE_CURRENT_SOURCE_DIR}/basic4.tesh ${CMAKE_CURRENT_SOURCE_DIR}/basic5.tesh ${CMAKE_CURRENT_SOURCE_DIR}/basic6.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/basic_platform.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/basic0.c ${CMAKE_CURRENT_SOURCE_DIR}/basic1.c ${CMAKE_CURRENT_SOURCE_DIR}/basic2.c ${CMAKE_CURRENT_SOURCE_DIR}/basic3.c ${CMAKE_CURRENT_SOURCE_DIR}/basic4.c ${CMAKE_CURRENT_SOURCE_DIR}/basic5.c ${CMAKE_CURRENT_SOURCE_DIR}/basic6.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/simdag/network/000755 001750 001750 00000000000 12342443670 017003 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/network/platform_2p_1sl.xml000644 001750 001750 00000000752 12342443670 022535 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/network/test_reinit_costs.c000644 001750 001750 00000004611 12342443665 022721 0ustar00cici000000 000000 /* Computation tests */ /* Copyright (c) 2007, 2009-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" /* * This test checks if the reinitialization of * surf works properly. * 1 test: empty task, reinit, empty task * 2 test: comm cost task, reinit, empty task * * output should be: * 0 * 1.5 */ static SD_task_t create_empty_cost_root() { double no_cost[] = { 0.0 }; SD_task_t root; root = SD_task_create("Root", NULL, 1.0); SD_task_schedule(root, 1, SD_workstation_get_list(), no_cost, no_cost, -1.0); return root; } static void zero_cost_test(int *argc, char *argv[]) { double time; SD_task_t task; xbt_dynar_t ret; SD_init(argc, argv); SD_create_environment(argv[1]); task = create_empty_cost_root(); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); SD_task_destroy(task); SD_application_reinit(); task = create_empty_cost_root(); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); SD_task_destroy(task); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); time = SD_get_clock(); printf("%g\n", time); fflush(stdout); SD_exit(); } static SD_task_t create_root_with_costs() { double comp_cost[] = { 0.0, 0.0 }; double comm_cost[] = { 0.0, 1.0, 0.0, 0.0 }; SD_task_t root; root = SD_task_create("Root", NULL, 1.0); SD_task_schedule(root, 2, SD_workstation_get_list(), comp_cost, comm_cost, -1.0); return root; } static void zero_cost_test2(int *argc, char *argv[]) { double time; SD_task_t task; xbt_dynar_t ret; SD_init(argc, argv); SD_create_environment(argv[1]); task = create_root_with_costs(); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); SD_task_destroy(task); SD_application_reinit(); task = create_empty_cost_root(); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); SD_task_destroy(task); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); time = SD_get_clock(); printf("%g\n", time); fflush(stdout); SD_exit(); } int main(int argc, char **argv) { zero_cost_test(&argc, argv); zero_cost_test2(&argc, argv); return 0; } SimGrid-3.11/teshsuite/simdag/network/p2p/000755 001750 001750 00000000000 12342443670 017504 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/network/p2p/test_latency2.tesh000644 001750 001750 00000001710 12342443664 023153 0ustar00cici000000 000000 p latency check, 2 x 1 byte, same direction, shared link ! output sort $ simdag/network/p2p/test_latency2 ${srcdir:=.}/simdag/network/p2p/platform_2p_1sl.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 2.5 p latency check, 2 x 1 byte, same direction, fat pipe ! output sort $ simdag/network/p2p/test_latency2 ${srcdir:=.}/simdag/network/p2p/platform_2p_1fl.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 1.5 p latency check, 2 x 1 byte, same direction, link - switch - link ! output sort $ simdag/network/p2p/test_latency2 ${srcdir:=.}/simdag/network/p2p/platform_2p_1switch.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 4 SimGrid-3.11/teshsuite/simdag/network/p2p/test_latency_bound.tesh000644 001750 001750 00000000470 12342443664 024262 0ustar00cici000000 000000 p latency bounded by large latency link ! output sort $ simdag/network/p2p/test_latency_bound ${srcdir:=.}/simdag/network/p2p/platform_2p_1bb.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 10001.5 SimGrid-3.11/teshsuite/simdag/network/p2p/platform_2p_1switch.xml000644 001750 001750 00000001133 12342443670 024113 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/network/p2p/test_latency3.tesh000644 001750 001750 00000001724 12342443664 023161 0ustar00cici000000 000000 p latency check, 2 x 1 byte, opposite direction, shared link ! output sort $ simdag/network/p2p/test_latency3 ${srcdir:=.}/simdag/network/p2p/platform_2p_1sl.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 2.5 p latency check, 2 x 1 byte, opposite direction, fat pipe ! output sort $ simdag/network/p2p/test_latency3 ${srcdir:=.}/simdag/network/p2p/platform_2p_1fl.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 1.5 p latency check, 2 x 1 byte, opposite direction, link - switch - link ! output sort $ simdag/network/p2p/test_latency3 ${srcdir:=.}/simdag/network/p2p/platform_2p_1switch.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 4 SimGrid-3.11/teshsuite/simdag/network/p2p/test_latency3.c000644 001750 001750 00000003333 12342443665 022437 0ustar00cici000000 000000 /* Latency tests */ /* Copyright (c) 2007, 2009-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" /** * bw and latency test 3 * same intention as test 2 * sending 2 x 1 bytes at the same time * this time in opposite direction * */ int main(int argc, char **argv) { double time; SD_task_t root; SD_task_t task1; SD_task_t task2; double communication_amount1[] = { 0.0, 1.0, 0.0, 0.0 }; double communication_amount2[] = { 0.0, 0.0, 1.0, 0.0 }; double no_cost1[] = { 0.0 }; double no_cost[] = { 0.0, 0.0 }; xbt_dynar_t ret; SD_init(&argc, argv); SD_create_environment(argv[1]); root = SD_task_create("Root", NULL, 1.0); task1 = SD_task_create("Comm 1", NULL, 1.0); task2 = SD_task_create("Comm 2", NULL, 1.0); SD_task_schedule(root, 1, SD_workstation_get_list(), no_cost1, no_cost1, -1.0); SD_task_schedule(task1, 2, SD_workstation_get_list(), no_cost, communication_amount1, -1.0); SD_task_schedule(task2, 2, SD_workstation_get_list(), no_cost, communication_amount2, -1.0); SD_task_dependency_add(NULL, NULL, root, task1); SD_task_dependency_add(NULL, NULL, root, task2); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); time = SD_get_clock(); printf("%g\n", time); fflush(stdout); SD_task_destroy(root); SD_task_destroy(task1); SD_task_destroy(task2); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/network/p2p/test_latency1.c000644 001750 001750 00000002224 12342443665 022433 0ustar00cici000000 000000 /* Latency tests */ /* Copyright (c) 2007, 2009-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" /* * simple latency test * send one byte from 0 to 1 * * this is a test for multiple platforms * see tesh file for expected output * */ int main(int argc, char **argv) { double time; double communication_amount[] = { 0.0, 1.0, 0.0, 0.0 }; const double no_cost[] = { 0.0, 0.0 }; SD_task_t task; xbt_dynar_t ret; SD_init(&argc, argv); SD_create_environment(argv[1]); task = SD_task_create("Comm 1", NULL, 1.0); SD_task_schedule(task, 2, SD_workstation_get_list(), no_cost, communication_amount, -1.0); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); time = SD_get_clock(); printf("%g\n", time); fflush(stdout); SD_task_destroy(task); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/network/p2p/test_latency2.c000644 001750 001750 00000003254 12342443665 022440 0ustar00cici000000 000000 /* Latency tests */ /* Copyright (c) 2007, 2009-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" /* * bw and latency test 2 * send 2 x 1 byte from 2 task in same direction 0 -> 1 * */ int main(int argc, char **argv) { double time; SD_task_t root; SD_task_t task1; SD_task_t task2; double communication_amount1[] = { 0.0, 1.0, 0.0, 0.0 }; double communication_amount2[] = { 0.0, 1.0, 0.0, 0.0 }; double no_cost1[] = { 0.0 }; double no_cost[] = { 0.0, 0.0 }; xbt_dynar_t ret; SD_init(&argc, argv); SD_create_environment(argv[1]); root = SD_task_create("Root", NULL, 1.0); task1 = SD_task_create("Comm 1", NULL, 1.0); task2 = SD_task_create("Comm 2", NULL, 1.0); SD_task_schedule(root, 1, SD_workstation_get_list(), no_cost1, no_cost1, -1.0); SD_task_schedule(task1, 2, SD_workstation_get_list(), no_cost, communication_amount1, -1.0); SD_task_schedule(task2, 2, SD_workstation_get_list(), no_cost, communication_amount2, -1.0); SD_task_dependency_add(NULL, NULL, root, task1); SD_task_dependency_add(NULL, NULL, root, task2); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); time = SD_get_clock(); printf("%g\n", time); fflush(stdout); SD_task_destroy(root); SD_task_destroy(task1); SD_task_destroy(task2); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/network/p2p/test_latency1.tesh000644 001750 001750 00000001614 12342443664 023155 0ustar00cici000000 000000 p latency check, 1 byte, shared link ! output sort $ simdag/network/p2p/test_latency1 ${srcdir:=.}/simdag/network/p2p/platform_2p_1sl.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 1.5 p latency check, 1 byte, fat pipe ! output sort $ simdag/network/p2p/test_latency1 ${srcdir:=.}/simdag/network/p2p/platform_2p_1fl.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 1.5 p latency check, 1 byte, link - switch - link ! output sort $ simdag/network/p2p/test_latency1 ${srcdir:=.}/simdag/network/p2p/platform_2p_1switch.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 3 SimGrid-3.11/teshsuite/simdag/network/p2p/platform_2p_1sl.xml000644 001750 001750 00000000603 12342443670 023231 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/network/p2p/platform_2p_1fl.xml000644 001750 001750 00000000604 12342443670 023215 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/network/p2p/test_latency_bound.c000644 001750 001750 00000003212 12342443665 023537 0ustar00cici000000 000000 /* Latency tests */ /* Copyright (c) 2007, 2009-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" #define TASK_NUM 3 /** * 3 tasks send 1 byte in parallel * 3 flows exceed bandwidth * should be 10001.5 * because the max tcp win size is 20000 * * @todo@ test assumes that max tcp win size is 20000 * assert this */ int main(int argc, char **argv) { int i; double time; double communication_amount[] = { 0.0, 1.0, 0.0, 0.0 }; double no_cost[] = { 0.0, 0.0 }; xbt_dynar_t ret; SD_task_t root; SD_task_t task[TASK_NUM]; SD_init(&argc, argv); SD_create_environment(argv[1]); // xbt_assert( check max tcp win size, "MAX TCP WIN SIZE is 20000"); root = SD_task_create("Root", NULL, 1.0); SD_task_schedule(root, 1, SD_workstation_get_list(), no_cost, no_cost, -1.0); for (i = 0; i < TASK_NUM; i++) { task[i] = SD_task_create("Comm", NULL, 1.0); SD_task_schedule(task[i], 2, SD_workstation_get_list(), no_cost, communication_amount, -1.0); SD_task_dependency_add(NULL, NULL, root, task[i]); } ret = SD_simulate(-1.0); xbt_dynar_free(&ret); time = SD_get_clock(); printf("%g\n", time); fflush(stdout); for (i = 0; i < TASK_NUM; i++) { SD_task_destroy(task[i]); } SD_task_destroy(root); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/network/p2p/platform_2p_1bb.xml000644 001750 001750 00000001155 12342443670 023201 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/network/p2p/CMakeLists.txt000644 001750 001750 00000003133 12342443654 022246 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(test_latency1 test_latency1.c) add_executable(test_latency2 test_latency2.c) add_executable(test_latency3 test_latency3.c) add_executable(test_latency_bound test_latency_bound.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(test_latency1 simgrid m pthread ) target_link_libraries(test_latency2 simgrid m pthread ) target_link_libraries(test_latency3 simgrid m pthread ) target_link_libraries(test_latency_bound simgrid m pthread ) else() target_link_libraries(test_latency1 simgrid) target_link_libraries(test_latency2 simgrid) target_link_libraries(test_latency3 simgrid) target_link_libraries(test_latency_bound simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/test_latency1.tesh ${CMAKE_CURRENT_SOURCE_DIR}/test_latency2.tesh ${CMAKE_CURRENT_SOURCE_DIR}/test_latency3.tesh ${CMAKE_CURRENT_SOURCE_DIR}/test_latency_bound.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/platform_2p_1bb.xml ${CMAKE_CURRENT_SOURCE_DIR}/platform_2p_1fl.xml ${CMAKE_CURRENT_SOURCE_DIR}/platform_2p_1sl.xml ${CMAKE_CURRENT_SOURCE_DIR}/platform_2p_1switch.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/test_latency1.c ${CMAKE_CURRENT_SOURCE_DIR}/test_latency2.c ${CMAKE_CURRENT_SOURCE_DIR}/test_latency3.c ${CMAKE_CURRENT_SOURCE_DIR}/test_latency_bound.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/simdag/network/mxn/000755 001750 001750 00000000000 12342443670 017605 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/network/mxn/test_intra_scatter.tesh000644 001750 001750 00000000435 12342443664 024400 0ustar00cici000000 000000 p scatter test ! output sort $ simdag/network/mxn/test_intra_scatter ${srcdir:=.}/simdag/network/mxn/platform_4p_1switch.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 8 SimGrid-3.11/teshsuite/simdag/network/mxn/test_intra_all2all.tesh000644 001750 001750 00000000512 12342443664 024252 0ustar00cici000000 000000 p all 2 all test, only fat pipe switch is used concurrently ! output sort $ simdag/network/mxn/test_intra_all2all ${srcdir:=.}/simdag/network/mxn/platform_4p_1switch.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 8 SimGrid-3.11/teshsuite/simdag/network/mxn/test_intra_all2all.c000644 001750 001750 00000002433 12342443665 023536 0ustar00cici000000 000000 /* Latency tests */ /* Copyright (c) 2007, 2009-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" /* * intra communication test * All2All * * send 1 byte from all to all * + 2 secs latency * should be 8 (platform_4p_1switch.xml) * */ int main(int argc, char **argv) { double time; SD_task_t task; xbt_dynar_t ret; double communication_amount[] = { 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, }; double no_cost[] = { 0.0, 0.0, 0.0, 0.0 }; /***************************************/ SD_init(&argc, argv); SD_create_environment(argv[1]); task = SD_task_create("All2all task", NULL, 1.0); SD_task_schedule(task, 4, SD_workstation_get_list(), no_cost, communication_amount, -1.0); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); time = SD_get_clock(); printf("%g\n", time); fflush(stdout); SD_task_destroy(task); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/network/mxn/test_intra_scatter.c000644 001750 001750 00000002664 12342443665 023666 0ustar00cici000000 000000 /* Latency tests */ /* Copyright (c) 2007, 2009-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" /* * intra communication test 1 * scatter * * start: 1 2 3 (each having 1/3 of the bandwidth) * after 3 sec: 0 1 2 (having 1/2 of the bandwidth) * after another 2 sec: 0 0 1 (having all the bandwidth) * -> finished after 1 sec * time to send: 6 + latency at the beginning: 0.5 + 1 + 0.5 */ int main(int argc, char **argv) { double time; SD_task_t task; xbt_dynar_t ret; double communication_amount[] = { 0.0, 1.0, 2.0, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, }; double no_cost[] = { 0.0, 0.0, 0.0, 0.0 }; /***************************************/ SD_init(&argc, argv); SD_create_environment(argv[1]); task = SD_task_create("Scatter task", NULL, 1.0); SD_task_schedule(task, 4, SD_workstation_get_list(), no_cost, communication_amount, -1.0); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); time = SD_get_clock(); printf("%g\n", time); fflush(stdout); SD_task_destroy(task); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/network/mxn/test_intra_independent_comm.tesh000644 001750 001750 00000000471 12342443664 026243 0ustar00cici000000 000000 p sending on different paths test ! output sort $ simdag/network/mxn/test_intra_independent_comm ${srcdir:=.}/simdag/network/mxn/platform_4p_1switch.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 3 SimGrid-3.11/teshsuite/simdag/network/mxn/test_intra_independent_comm.c000644 001750 001750 00000002445 12342443665 025526 0ustar00cici000000 000000 /* Latency tests */ /* Copyright (c) 2007, 2009-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" /* * intra communication test * independent communication * * 0 -> 1 * 2 -> 3 * shared is only switch which is fat pipe * should be 1 + 2 latency = 3 */ int main(int argc, char **argv) { double time; SD_task_t task; xbt_dynar_t ret; double communication_amount[] = { 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, }; double no_cost[] = { 0.0, 0.0, 0.0, 0.0 }; /***************************************/ SD_init(&argc, argv); SD_create_environment(argv[1]); task = SD_task_create("Comm 1", NULL, 1.0); SD_task_schedule(task, 4, SD_workstation_get_list(), no_cost, communication_amount, -1.0); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); time = SD_get_clock(); printf("%g\n", time); fflush(stdout); SD_task_destroy(task); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/network/mxn/platform_4p_1switch.xml000644 001750 001750 00000002733 12342443670 024225 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/network/mxn/CMakeLists.txt000644 001750 001750 00000002501 12342443654 022345 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(test_intra_all2all test_intra_all2all.c) add_executable(test_intra_independent_comm test_intra_independent_comm.c) add_executable(test_intra_scatter test_intra_scatter.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(test_intra_all2all simgrid m pthread ) target_link_libraries(test_intra_independent_comm simgrid m pthread ) target_link_libraries(test_intra_scatter simgrid m pthread ) else() target_link_libraries(test_intra_all2all simgrid) target_link_libraries(test_intra_independent_comm simgrid) target_link_libraries(test_intra_scatter simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/test_intra_all2all.tesh ${CMAKE_CURRENT_SOURCE_DIR}/test_intra_independent_comm.tesh ${CMAKE_CURRENT_SOURCE_DIR}/test_intra_scatter.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/platform_4p_1switch.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/test_intra_all2all.c ${CMAKE_CURRENT_SOURCE_DIR}/test_intra_independent_comm.c ${CMAKE_CURRENT_SOURCE_DIR}/test_intra_scatter.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/simdag/network/CMakeLists.txt000644 001750 001750 00000001331 12342443654 021543 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(test_reinit_costs test_reinit_costs.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(test_reinit_costs simgrid m pthread ) else() target_link_libraries(test_reinit_costs simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/test_reinit_costs.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/platform_2p_1sl.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/test_reinit_costs.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/simdag/network/test_reinit_costs.tesh000644 001750 001750 00000000532 12342443664 023437 0ustar00cici000000 000000 p Reinitialization test ! output sort $ simdag/network/test_reinit_costs ${srcdir:=.}/simdag/network/platform_2p_1sl.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 0 > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 1.5 SimGrid-3.11/teshsuite/simdag/availability/000755 001750 001750 00000000000 12342443670 017764 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/availability/simulacrum_7_hosts.xml000644 001750 001750 00000014073 12342443670 024342 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/availability/linkBandwidth7.bw000644 001750 001750 00000000252 12342443666 023173 0ustar00cici000000 000000 PERIODICITY 8.0 1.007044263744508 6.846527733924368E7 4.199387092709633 1.0335587797993976E8 5.319464737378834 1.0591433767387845E7 7.237437222882919 7.037797434537312E7 SimGrid-3.11/teshsuite/simdag/availability/availability_test.tesh000644 001750 001750 00000003360 12342443664 024367 0ustar00cici000000 000000 ! output sort $ simdag/availability/availability_test ${srcdir:=.}/simdag/availability/simulacrum_7_hosts.xml --cfg=path:${srcdir:=.}/simdag/availability/ ${srcdir:=.}/../examples/simdag/scheduling/Montage_25.xml --cfg=network/TCP_gamma:4194304 --log=sd_daxparse.thresh:critical > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304' > [0.000000] [surf_workstation/INFO] surf_workstation_model_init_ptask_L07 > Scheduling DAX... > Scheduling root to node: Host 26 > Scheduling ID00000@mProjectPP to node: Host 27 > Scheduling ID00001@mProjectPP to node: Host 28 > Scheduling ID00002@mProjectPP to node: Host 29 > Scheduling ID00003@mProjectPP to node: Host 30 > Scheduling ID00004@mProjectPP to node: Host 31 > Scheduling ID00005@mDiffFit to node: Host 32 > Scheduling ID00006@mDiffFit to node: Host 26 > Scheduling ID00007@mDiffFit to node: Host 27 > Scheduling ID00008@mDiffFit to node: Host 28 > Scheduling ID00009@mDiffFit to node: Host 29 > Scheduling ID00010@mDiffFit to node: Host 30 > Scheduling ID00011@mDiffFit to node: Host 31 > Scheduling ID00012@mDiffFit to node: Host 32 > Scheduling ID00013@mDiffFit to node: Host 26 > Scheduling ID00014@mConcatFit to node: Host 27 > Scheduling ID00015@mBgModel to node: Host 28 > Scheduling ID00016@mBackground to node: Host 29 > Scheduling ID00017@mBackground to node: Host 30 > Scheduling ID00018@mBackground to node: Host 31 > Scheduling ID00019@mBackground to node: Host 32 > Scheduling ID00020@mBackground to node: Host 26 > Scheduling ID00021@mImgTbl to node: Host 27 > Scheduling ID00022@mAdd to node: Host 28 > Scheduling ID00023@mShrink to node: Host 29 > Scheduling ID00024@mJPEG to node: Host 30 > Scheduling end to node: Host 26 > DAX scheduled > Simulation end. Time: 164.052870 SimGrid-3.11/teshsuite/simdag/availability/availability_test.c000644 001750 001750 00000010715 12342443665 023651 0ustar00cici000000 000000 /* Copyright (c) 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include #include #include #include #include #include #include typedef struct { FILE *daxFile; FILE *envFile; } XMLfiles; static void usage(char *name) { fprintf(stdout, "Error on parameters.\n"); fprintf(stdout, "usage: %s \n", name); } static void checkParameters(int argc, char *argv[]) { if (argc != 3) { int i; printf("====%d===\n",argc); for(i=0; i #include #include "simdag/simdag.h" int main(int argc, char **argv) { double time; double comm_amount[] = { 0.0 }; double comp_cost[] = { 1.0 }; SD_task_t task; xbt_dynar_t ret; SD_init(&argc, argv); SD_create_environment(argv[1]); task = SD_task_create("seqtask", NULL, 1.0); SD_task_schedule(task, 1, SD_workstation_get_list(), comp_cost, comm_amount, -1.0); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); time = SD_get_clock(); printf("%g\n", time); fflush(stdout); SD_task_destroy(task); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/partask/test_comp_only_seq.tesh000644 001750 001750 00000000440 12342443664 023553 0ustar00cici000000 000000 p seq task comp only, no comm ! output sort $ simdag/partask/test_comp_only_seq ${srcdir:=.}/simdag/partask/platform_2p_1sl.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 1 SimGrid-3.11/teshsuite/simdag/partask/test_comp_only_par.c000644 001750 001750 00000001640 12342443665 023030 0ustar00cici000000 000000 /* Copyright (c) 2007, 2009-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" int main(int argc, char **argv) { double time; double comm_amount[] = { 0.0, 0.0, 0.0, 0.0 }; double comp_cost[] = { 1.0, 1.0 }; SD_task_t task; xbt_dynar_t ret; SD_init(&argc, argv); SD_create_environment(argv[1]); task = SD_task_create("partask", NULL, 1.0); SD_task_schedule(task, 2, SD_workstation_get_list(), comp_cost, comm_amount, -1.0); ret = SD_simulate(-1.0); xbt_dynar_free(&ret); time = SD_get_clock(); printf("%g\n", time); fflush(stdout); SD_task_destroy(task); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/partask/test_comp_only_par.tesh000644 001750 001750 00000001141 12342443664 023544 0ustar00cici000000 000000 p par task comp only, no comm, homogeneous ! output sort $ simdag/partask/test_comp_only_par ${srcdir:=.}/simdag/partask/platform_2p_1sl.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 1 p par task comp only, no comm, heterogeneous ! output sort $ simdag/partask/test_comp_only_par ${srcdir:=.}/simdag/partask/platform_2p_1sl_hetero.xml --cfg=path:${srcdir} --log=sd_kernel.thres=warning "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > 1 SimGrid-3.11/teshsuite/simdag/partask/platform_2p_1sl_hetero.xml000644 001750 001750 00000000607 12342443670 024056 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/partask/platform_2p_1sl.xml000644 001750 001750 00000000607 12342443670 022510 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/partask/CMakeLists.txt000644 001750 001750 00000002054 12342443654 021522 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(test_comp_only_seq test_comp_only_seq.c) add_executable(test_comp_only_par test_comp_only_par.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(test_comp_only_seq simgrid m pthread ) target_link_libraries(test_comp_only_par simgrid m pthread ) else() target_link_libraries(test_comp_only_seq simgrid) target_link_libraries(test_comp_only_par simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/test_comp_only_par.tesh ${CMAKE_CURRENT_SOURCE_DIR}/test_comp_only_seq.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/platform_2p_1sl_hetero.xml ${CMAKE_CURRENT_SOURCE_DIR}/platform_2p_1sl.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/test_comp_only_par.c ${CMAKE_CURRENT_SOURCE_DIR}/test_comp_only_seq.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/simdag/platforms/000755 001750 001750 00000000000 12342443670 017321 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/two_hosts_one_link_fullduplex.xml000644 001750 001750 00000001041 12342443670 026212 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_host_state_file.xml000644 001750 001750 00000000351 12342443670 024057 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/bogus_disk_attachment.tesh000644 001750 001750 00000000456 12342443665 024560 0ustar00cici000000 000000 ! expect signal SIGABRT $ ${bindir:=.}/flatifier bogus_disk_attachment.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > [ 0.000000] [0:@] Parse error at bogus_disk_attachment.xml:26: Unable to attach storage cdisk: host plouf doesn't exist. SimGrid-3.11/teshsuite/simdag/platforms/one_cluster_one_host_random.xml000644 001750 001750 00000001127 12342443670 025624 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/bob.fail000644 001750 001750 00000000042 12342443666 020721 0ustar00cici000000 000000 PERIODICITY 10.0 1.0 -1.0 2.0 1.0 SimGrid-3.11/teshsuite/simdag/platforms/four_hosts_floyd.xml000644 001750 001750 00000001516 12342443670 023436 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/link1.fail000644 001750 001750 00000000042 12342443666 021175 0ustar00cici000000 000000 PERIODICITY 10.0 1.0 -1.0 2.0 1.0 SimGrid-3.11/teshsuite/simdag/platforms/link1.bw000644 001750 001750 00000000053 12342443666 020674 0ustar00cici000000 000000 PERIODICITY 12.0 4.0 40000000 8.0 60000000 SimGrid-3.11/teshsuite/simdag/platforms/is_router_test.c000644 001750 001750 00000002404 12342443665 022543 0ustar00cici000000 000000 /* Copyright (c) 2008-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" #include "surf/surf_private.h" extern routing_platf_t routing_platf; int main(int argc, char **argv) { /* initialisation of SD */ int size; xbt_lib_cursor_t cursor = NULL; char *key, *data; #ifdef _XBT_WIN32 setbuf(stderr, NULL); setbuf(stdout, NULL); #endif SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); size = xbt_lib_length(host_lib) + xbt_lib_length(as_router_lib); printf("Workstation number: %d, link number: %d, elmts number: %d\n", SD_workstation_get_number(), SD_link_get_number(), size); xbt_lib_foreach(host_lib, cursor, key, data) { printf(" - Seen: \"%s\" is type : %d\n", key, (int) routing_get_network_element_type(key)); } xbt_lib_foreach(as_router_lib, cursor, key, data) { printf(" - Seen: \"%s\" is type : %d\n", key, (int) routing_get_network_element_type(key)); } SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/platforms/one_cluster_file.xml000644 001750 001750 00000000667 12342443670 023375 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/bob.trace000644 001750 001750 00000000052 12342443666 021105 0ustar00cici000000 000000 PERIODICITY 1.0 0.0 1.0 11.0 0.5 20.0 0.8 SimGrid-3.11/teshsuite/simdag/platforms/one_host_state_off.xml000644 001750 001750 00000000337 12342443670 023716 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/bogus_two_hosts_asymetric-2.xml000644 001750 001750 00000001620 12342443670 025511 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_host_trace_file.xml000644 001750 001750 00000000500 12342443670 024031 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/basic_link_test.c000644 001750 001750 00000002413 12342443665 022626 0ustar00cici000000 000000 /* Copyright (c) 2008-2010, 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" #include "surf/surf_private.h" #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(basic_link_test, sd, "SimDag test basic_link_test"); int main(int argc, char **argv) { int i; const char *user_data = "some user_data"; const SD_link_t *links; /* initialization of SD */ SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); XBT_INFO("Link number: %d", SD_link_get_number()); links = SD_link_get_list(); for(i=0; i SimGrid-3.11/teshsuite/simdag/platforms/clusterB.xml000644 001750 001750 00000000275 12342443670 021632 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_cluster_fullduplex.xml000644 001750 001750 00000000542 12342443670 024632 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_cluster_one_host.xml000644 001750 001750 00000001043 12342443670 024261 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/four_hosts_Dijkstra_ns3.xml000644 001750 001750 00000001610 12342443670 024652 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/random.xml000644 001750 001750 00000004537 12342443670 021334 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/two_hosts_multi_hop.xml000644 001750 001750 00000001123 12342443670 024151 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/Evaluate_parse_time.c000644 001750 001750 00000002175 12342443665 023454 0ustar00cici000000 000000 /* Copyright (c) 2008-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ //teshsuite/simdag/platforms/evaluate_parse_time ../examples/platforms/nancy.xml #include #include #include "simdag/simdag.h" #include "surf/surf_private.h" #include "xbt/xbt_os_time.h" extern routing_platf_t routing_platf; int main(int argc, char **argv) { xbt_os_timer_t timer = xbt_os_timer_new(); /* initialization of SD */ SD_init(&argc, argv); /* creation of the environment, timed */ xbt_os_cputimer_start(timer); SD_create_environment(argv[1]); xbt_os_cputimer_stop(timer); /* Display the result and exit after cleanup */ printf( "%f\n", xbt_os_timer_elapsed(timer) ); printf("Workstation number: %d, link number: %d\n", SD_workstation_get_number(), SD_link_get_number()); if(argv[2]){ printf("Wait for %ss\n",argv[2]); sleep(atoi(argv[2])); } SD_exit(); free(timer); return 0; } SimGrid-3.11/teshsuite/simdag/platforms/one_cluster_properties_override.xml000644 001750 001750 00000001006 12342443670 026535 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/bob2_state_file.trace000644 001750 001750 00000000052 12342443666 023366 0ustar00cici000000 000000 PERIODICITY 1.0 0.0 1.0 11.0 0.5 20.0 0.8 SimGrid-3.11/teshsuite/simdag/platforms/basic_parsing_test.c000644 001750 001750 00000006301 12342443665 023334 0ustar00cici000000 000000 /* Copyright (c) 2008-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" #include "surf/surf_private.h" int main(int argc, char **argv) { /* initialisation of SD */ SD_workstation_t w1, w2; const SD_workstation_t *workstations; const SD_link_t *route; const char *name1; const char *name2; int route_size, i, j, k; int list_size; #ifdef _XBT_WIN32 setbuf(stderr, NULL); setbuf(stdout, NULL); #else setvbuf(stdout, NULL, _IOLBF, 0); #endif SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); printf("Workstation number: %d, link number: %d\n", SD_workstation_get_number(), SD_link_get_number()); if (argc >= 3) { if (!strcmp(argv[2], "ONE_LINK")) { workstations = SD_workstation_get_list(); w1 = workstations[0]; w2 = workstations[1]; name1 = SD_workstation_get_name(w1); name2 = SD_workstation_get_name(w2); printf("Route between %s and %s\n", name1, name2); route = SD_route_get_list(w1, w2); route_size = SD_route_get_size(w1, w2); printf("Route size %d\n", route_size); for (i = 0; i < route_size; i++) { printf(" Link %s: latency = %f, bandwidth = %f\n", SD_link_get_name(route[i]), SD_link_get_current_latency(route[i]), SD_link_get_current_bandwidth(route[i])); } printf("Route latency = %f, route bandwidth = %f\n", SD_route_get_current_latency(w1, w2), SD_route_get_current_bandwidth(w1, w2)); } if (!strcmp(argv[2], "FULL_LINK")) { workstations = SD_workstation_get_list(); list_size = SD_workstation_get_number(); for (i = 0; i < list_size; i++) { w1 = workstations[i]; name1 = SD_workstation_get_name(w1); for (j = 0; j < list_size; j++) { w2 = workstations[j]; name2 = SD_workstation_get_name(w2); printf("Route between %s and %s\n", name1, name2); route = SD_route_get_list(w1, w2); route_size = SD_route_get_size(w1, w2); printf(" Route size %d\n", route_size); for (k = 0; k < route_size; k++) { printf(" Link %s: latency = %f, bandwidth = %f\n", SD_link_get_name(route[k]), SD_link_get_current_latency(route[k]), SD_link_get_current_bandwidth(route[k])); } printf(" Route latency = %f, route bandwidth = %f\n", SD_route_get_current_latency(w1, w2), SD_route_get_current_bandwidth(w1, w2)); } } } if (!strcmp(argv[2], "PROP")) { printf("SG_TEST_mem: %s\n", SD_workstation_get_property_value(SD_workstation_get_by_name("host1"), "SG_TEST_mem") ); printf("Author: %s\n", SD_as_router_get_property_value("AS0", "author")); printf("AS1: %s\n", SD_as_router_get_property_value("AS1", "name")); printf("AS2: %s\n", SD_as_router_get_property_value("AS2", "name")); } } SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/platforms/four_hosts_floyd_bis.xml000644 001750 001750 00000002176 12342443670 024276 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_cluster_router_id.xml000644 001750 001750 00000000542 12342443670 024442 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/clusterA.xml000644 001750 001750 00000000275 12342443670 021631 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/bogus_missing_gateway.tesh000644 001750 001750 00000001226 12342443665 024604 0ustar00cici000000 000000 ! expect signal SIGABRT $ ${bindir:=.}/flatifier bogus_missing_src_gateway.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > [ 0.000000] [0:@] Parse error at bogus_missing_src_gateway.xml:16: gw_src="nod-cluster_router.cluster.us" not found for ASroute from "us" to "fr" ! expect signal SIGABRT $ ${bindir:=.}/flatifier bogus_missing_dst_gateway.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > [ 0.000000] [0:@] Parse error at bogus_missing_dst_gateway.xml:16: gw_dst="neud-grappe_router.grappe.fr" not found for ASroute from "us" to "fr" SimGrid-3.11/teshsuite/simdag/platforms/basic_parsing_test_sym_full.tesh000644 001750 001750 00000050247 12342443664 025776 0ustar00cici000000 000000 #! ./tesh ! output sort $ ${bindir:=.}/basic_parsing_test one_cluster_fullduplex.xml FULL_LINK "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 5, link number: 12 > Route between bob3.hamburger.edu and bob3.hamburger.edu > Route size 3 > Link bob_cluster_link_3_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_3_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob3.hamburger.edu and bob0.hamburger.edu > Route size 3 > Link bob_cluster_link_3_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob3.hamburger.edu and bob2.hamburger.edu > Route size 3 > Link bob_cluster_link_3_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_2_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob3.hamburger.edu and bob4.hamburger.edu > Route size 3 > Link bob_cluster_link_3_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_4_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob3.hamburger.edu and bob6.hamburger.edu > Route size 3 > Link bob_cluster_link_3_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_6_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob0.hamburger.edu and bob3.hamburger.edu > Route size 3 > Link bob_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_3_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob0.hamburger.edu and bob0.hamburger.edu > Route size 3 > Link bob_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob0.hamburger.edu and bob2.hamburger.edu > Route size 3 > Link bob_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_2_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob0.hamburger.edu and bob4.hamburger.edu > Route size 3 > Link bob_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_4_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob0.hamburger.edu and bob6.hamburger.edu > Route size 3 > Link bob_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_6_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob2.hamburger.edu and bob3.hamburger.edu > Route size 3 > Link bob_cluster_link_2_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_3_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob2.hamburger.edu and bob0.hamburger.edu > Route size 3 > Link bob_cluster_link_2_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob2.hamburger.edu and bob2.hamburger.edu > Route size 3 > Link bob_cluster_link_2_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_2_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob2.hamburger.edu and bob4.hamburger.edu > Route size 3 > Link bob_cluster_link_2_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_4_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob2.hamburger.edu and bob6.hamburger.edu > Route size 3 > Link bob_cluster_link_2_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_6_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob4.hamburger.edu and bob3.hamburger.edu > Route size 3 > Link bob_cluster_link_4_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_3_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob4.hamburger.edu and bob0.hamburger.edu > Route size 3 > Link bob_cluster_link_4_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob4.hamburger.edu and bob2.hamburger.edu > Route size 3 > Link bob_cluster_link_4_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_2_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob4.hamburger.edu and bob4.hamburger.edu > Route size 3 > Link bob_cluster_link_4_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_4_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob4.hamburger.edu and bob6.hamburger.edu > Route size 3 > Link bob_cluster_link_4_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_6_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob6.hamburger.edu and bob3.hamburger.edu > Route size 3 > Link bob_cluster_link_6_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_3_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob6.hamburger.edu and bob0.hamburger.edu > Route size 3 > Link bob_cluster_link_6_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob6.hamburger.edu and bob2.hamburger.edu > Route size 3 > Link bob_cluster_link_6_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_2_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob6.hamburger.edu and bob4.hamburger.edu > Route size 3 > Link bob_cluster_link_6_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_4_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob6.hamburger.edu and bob6.hamburger.edu > Route size 3 > Link bob_cluster_link_6_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_6_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 $ ${bindir:=.}/basic_parsing_test two_clusters_symmetric.xml FULL_LINK "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 4, link number: 12 > Route between bob1.hamburger.edu and bob1.hamburger.edu > Route size 3 > Link bob_cluster_link_1_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_1_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob1.hamburger.edu and bob0.hamburger.edu > Route size 3 > Link bob_cluster_link_1_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob1.hamburger.edu and alice0.crepe.fr > Route size 5 > Link bob_cluster_link_1_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link alice_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link alice_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001600, route bandwidth = 125000000.000000 > Route between bob1.hamburger.edu and alice1.crepe.fr > Route size 5 > Link bob_cluster_link_1_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link alice_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link alice_cluster_link_1_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001600, route bandwidth = 125000000.000000 > Route between bob0.hamburger.edu and bob1.hamburger.edu > Route size 3 > Link bob_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_1_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob0.hamburger.edu and bob0.hamburger.edu > Route size 3 > Link bob_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between bob0.hamburger.edu and alice0.crepe.fr > Route size 5 > Link bob_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link alice_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link alice_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001600, route bandwidth = 125000000.000000 > Route between bob0.hamburger.edu and alice1.crepe.fr > Route size 5 > Link bob_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link alice_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link alice_cluster_link_1_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001600, route bandwidth = 125000000.000000 > Route between alice0.crepe.fr and bob1.hamburger.edu > Route size 5 > Link alice_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link alice_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_1_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001600, route bandwidth = 125000000.000000 > Route between alice0.crepe.fr and bob0.hamburger.edu > Route size 5 > Link alice_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link alice_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001600, route bandwidth = 125000000.000000 > Route between alice0.crepe.fr and alice0.crepe.fr > Route size 3 > Link alice_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link alice_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link alice_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between alice0.crepe.fr and alice1.crepe.fr > Route size 3 > Link alice_cluster_link_0_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link alice_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link alice_cluster_link_1_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between alice1.crepe.fr and bob1.hamburger.edu > Route size 5 > Link alice_cluster_link_1_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link alice_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_1_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001600, route bandwidth = 125000000.000000 > Route between alice1.crepe.fr and bob0.hamburger.edu > Route size 5 > Link alice_cluster_link_1_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link alice_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link bob_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link bob_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001600, route bandwidth = 125000000.000000 > Route between alice1.crepe.fr and alice0.crepe.fr > Route size 3 > Link alice_cluster_link_1_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link alice_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link alice_cluster_link_0_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 > Route between alice1.crepe.fr and alice1.crepe.fr > Route size 3 > Link alice_cluster_link_1_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link alice_cluster_backbone: latency = 0.000500, bandwidth = 2250000000.000000 > Link alice_cluster_link_1_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000600, route bandwidth = 125000000.000000 $ ${bindir:=.}/basic_parsing_test two_hosts_one_link_symmetrical.xml FULL_LINK "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 2, link number: 4 > Route between alice and alice > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between alice and bob > Route size 3 > Link link3: latency = 0.000050, bandwidth = 125000000.000000 > Link link2: latency = 0.000050, bandwidth = 125000000.000000 > Link link1: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000150, route bandwidth = 125000000.000000 > Route between bob and alice > Route size 3 > Link link1: latency = 0.000050, bandwidth = 125000000.000000 > Link link2: latency = 0.000050, bandwidth = 125000000.000000 > Link link3: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000150, route bandwidth = 125000000.000000 > Route between bob and bob > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 $ ${bindir:=.}/basic_parsing_test two_hosts_one_link_fullduplex.xml FULL_LINK "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 2, link number: 3 > Route between alice and alice > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between alice and bob > Route size 1 > Link link1_UP: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between bob and alice > Route size 1 > Link link1_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between bob and bob > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 $ ${bindir:=.}/basic_parsing_test Dijkstra.xml FULL_LINK "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 2, link number: 6 > Route between NODO01 and NODO01 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between NODO01 and NODO02 > Route size 2 > Link 1: latency = 0.001000, bandwidth = 1000000.000000 > Link 2: latency = 0.001000, bandwidth = 1000000.000000 > Route latency = 0.002000, route bandwidth = 1000000.000000 > Route between NODO02 and NODO01 > Route size 2 > Link 2: latency = 0.001000, bandwidth = 1000000.000000 > Link 1: latency = 0.001000, bandwidth = 1000000.000000 > Route latency = 0.002000, route bandwidth = 1000000.000000 > Route between NODO02 and NODO02 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 SimGrid-3.11/teshsuite/simdag/platforms/platform_include.xml000644 001750 001750 00000000373 12342443670 023375 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/bogus_disk_attachment.xml000644 001750 001750 00000001426 12342443670 024407 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/basic_link_test.tesh000644 001750 001750 00000002427 12342443664 023353 0ustar00cici000000 000000 #! ./tesh $ ${bindir:=.}/basic_link_test one_cluster.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > [ 0.000000] (0:@) Link number: 12 > [ 0.000000] (0:@) bob_cluster_link_2_UP: latency = 0.00005, bandwidth = 125000000.000000 > [ 0.000000] (0:@) bob_cluster_link_6_UP: latency = 0.00005, bandwidth = 125000000.000000 > [ 0.000000] (0:@) bob_cluster_link_2_DOWN: latency = 0.00005, bandwidth = 125000000.000000 > [ 0.000000] (0:@) bob_cluster_link_6_DOWN: latency = 0.00005, bandwidth = 125000000.000000 > [ 0.000000] (0:@) __loopback__: latency = 0.00002, bandwidth = 498000000.000000 > [ 0.000000] (0:@) bob_cluster_backbone: latency = 0.00050, bandwidth = 2250000000.000000 > [ 0.000000] (0:@) bob_cluster_link_3_DOWN: latency = 0.00005, bandwidth = 125000000.000000 > [ 0.000000] (0:@) bob_cluster_link_0_UP: latency = 0.00005, bandwidth = 125000000.000000 > [ 0.000000] (0:@) bob_cluster_link_4_UP: latency = 0.00005, bandwidth = 125000000.000000 > [ 0.000000] (0:@) bob_cluster_link_0_DOWN: latency = 0.00005, bandwidth = 125000000.000000 > [ 0.000000] (0:@) bob_cluster_link_4_DOWN: latency = 0.00005, bandwidth = 125000000.000000 > [ 0.000000] (0:@) bob_cluster_link_3_UP: latency = 0.00005, bandwidth = 125000000.000000 SimGrid-3.11/teshsuite/simdag/platforms/test_of_is_router.xml000644 001750 001750 00000001566 12342443670 023611 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/basic_parsing_test.tesh000644 001750 001750 00000013254 12342443664 024061 0ustar00cici000000 000000 ! output sort $ ${bindir:=.}/basic_parsing_test one_cluster.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 5, link number: 12 $ ${bindir:=.}/basic_parsing_test one_host_availability.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 1, link number: 1 $ ${bindir:=.}/basic_parsing_test one_host_properties.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 1, link number: 1 $ ${bindir:=.}/basic_parsing_test one_host_state_file.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 1, link number: 1 $ ${bindir:=.}/basic_parsing_test one_host_state_off.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 1, link number: 1 $ ${bindir:=.}/basic_parsing_test one_host_state_on.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 1, link number: 1 $ ${bindir:=.}/basic_parsing_test one_host_trace_file.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 1, link number: 1 $ ${bindir:=.}/basic_parsing_test one_host_trace_inside.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 1, link number: 1 $ ${bindir:=.}/basic_parsing_test one_host.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 1, link number: 1 $ ${bindir:=.}/basic_parsing_test one_link_availability.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 1, link number: 2 $ ${bindir:=.}/basic_parsing_test one_link_fatpipe.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 1, link number: 2 $ ${bindir:=.}/basic_parsing_test one_link_shared.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 1, link number: 2 $ ${bindir:=.}/basic_parsing_test one_link_state_file.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 1, link number: 2 $ ${bindir:=.}/basic_parsing_test three_hosts_non_symmetric_route.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 3, link number: 4 $ ${bindir:=.}/basic_parsing_test two_clusters.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 10, link number: 24 $ ${bindir:=.}/basic_parsing_test two_hosts_multi_hop.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 2, link number: 4 $ ${bindir:=.}/basic_parsing_test two_hosts_one_link.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) surf_workstation_model_init_ptask_L07 > Workstation number: 2, link number: 2 $ ${bindir:=.}/basic_parsing_test ./four_hosts_floyd.xml > [0.000000] [surf_workstation/INFO] surf_workstation_model_init_ptask_L07 > Workstation number: 4, link number: 5 $ ${bindir:=.}/basic_parsing_test ./four_hosts_floyd_bis.xml > [0.000000] [surf_workstation/INFO] surf_workstation_model_init_ptask_L07 > Workstation number: 5, link number: 7 $ ${bindir:=.}/basic_parsing_test ./properties.xml > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'cpu/optim' to 'TI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '0.000010' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'workstation/model' to 'compound' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'Vegas' > Workstation number: 1, link number: 1 $ ${bindir:=.}/basic_parsing_test ./properties.xml --cfg=cpu/optim:TI > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'cpu/optim' to 'TI' > [0.000000] [surf_parse/INFO] The custom configuration 'cpu/optim' is already defined by user! > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '0.000010' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'workstation/model' to 'compound' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'Vegas' > Workstation number: 1, link number: 1 $ ${bindir:=.}/basic_parsing_test ./one_cluster_file.xml > [0.000000] [surf_workstation/INFO] surf_workstation_model_init_ptask_L07 > Workstation number: 2, link number: 6 $ ${bindir:=.}/is_router_test ./test_of_is_router.xml > [0.000000] [surf_workstation/INFO] surf_workstation_model_init_ptask_L07 > Workstation number: 10, link number: 1, elmts number: 21 > - Seen: "host01" is type : 1 > - Seen: "host02" is type : 1 > - Seen: "host03" is type : 1 > - Seen: "host04" is type : 1 > - Seen: "host05" is type : 1 > - Seen: "host06" is type : 1 > - Seen: "host07" is type : 1 > - Seen: "host08" is type : 1 > - Seen: "host09" is type : 1 > - Seen: "host10" is type : 1 > - Seen: "router1" is type : 2 > - Seen: "router2" is type : 2 > - Seen: "router3" is type : 2 > - Seen: "router4" is type : 2 > - Seen: "router5" is type : 2 > - Seen: "AS0" is type : 3 > - Seen: "AS1" is type : 3 > - Seen: "AS2" is type : 3 > - Seen: "AS3" is type : 3 > - Seen: "AS4" is type : 3 > - Seen: "AS" is type : 3 SimGrid-3.11/teshsuite/simdag/platforms/one_link_state_file.xml000644 001750 001750 00000000443 12342443670 024041 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/bogus_two_hosts_asymetric.tesh000644 001750 001750 00000001553 12342443664 025525 0ustar00cici000000 000000 ! expect signal SIGABRT $ ${bindir:=.}/flatifier bogus_two_hosts_asymetric.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > [ 0.000000] [0:@] Parse error at bogus_two_hosts_asymetric.xml:24: A route between "alice" and "bob" already exists with a different content. If you are trying to define a reverse route, you must set the symmetrical=no attribute to your routes tags. ! expect signal SIGABRT $ ${bindir:=.}/flatifier bogus_two_hosts_asymetric-2.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > [ 0.000000] [0:@] Parse error at bogus_two_hosts_asymetric-2.xml:26: A route between "alice" and "bob" already exists with a different content. If you are trying to define a reverse route, you must set the symmetrical=no attribute to your routes tags. SimGrid-3.11/teshsuite/simdag/platforms/one_host_state_on.xml000644 001750 001750 00000000336 12342443670 023557 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/Evaluate_get_route_time.c000644 001750 001750 00000002577 12342443665 024345 0ustar00cici000000 000000 /* Copyright (c) 2008-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ //for i in $(seq 1 100); do teshsuite/simdag/platforms/evaluate_get_route_time ../examples/platforms/cluster.xml 1 2> /tmp/null ; done #include #include #include "simdag/simdag.h" #include "surf/surf_private.h" #include "xbt/xbt_os_time.h" #define BILLION 1000000000L; extern routing_platf_t routing_platf; int main(int argc, char **argv) { SD_workstation_t w1, w2; const SD_workstation_t *workstations; int i, j; int list_size; xbt_os_timer_t timer = xbt_os_timer_new(); /* initialisation of SD */ SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); workstations = SD_workstation_get_list(); list_size = SD_workstation_get_number(); /* Random number initialization */ srand( (int) (xbt_os_time()*1000) ); do{ i = rand()%list_size; j = rand()%list_size; }while(i==j); w1 = workstations[i]; w2 = workstations[j]; printf("%d\tand\t%d\t\t",i,j); xbt_os_cputimer_start(timer); SD_route_get_list(w1, w2); xbt_os_cputimer_stop(timer); printf("%f\n", xbt_os_timer_elapsed(timer) ); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/platforms/flatifier.tesh000644 001750 001750 00000306270 12342443664 022166 0ustar00cici000000 000000 #! ./tesh ! output sort $ ${bindir:=.}/flatifier$EXEEXT one_cluster.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_cluster_multicore.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_host_availability.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_host_properties.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_host_state_file.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_host_state_off.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_host_state_on.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_host_trace_file.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_host_trace_inside.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_host.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_link_availability.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_link_fatpipe.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_link_shared.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT one_link_state_file.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT three_hosts_non_symmetric_route.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT two_clusters.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT two_hosts_multi_hop.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > > > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT two_hosts_one_link.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT ${srcdir:=.}/examples/platforms/bypassASroute.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > $ ${bindir:=.}/flatifier$EXEEXT ${srcdir:=.}/examples/platforms/torus_cluster.xml "--log=root.fmt:[%10.6r]%e[%i:%P@%h]%e%m%n" > [ 0.000000] [0:@] surf_workstation_model_init_ptask_L07 > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > SimGrid-3.11/teshsuite/simdag/platforms/two_clusters_one_name.xml000644 001750 001750 00000002071 12342443670 024441 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/two_hosts_one_link_symmetrical.xml000644 001750 001750 00000001056 12342443670 026365 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/two_clusters_symmetric.xml000644 001750 001750 00000001451 12342443670 024675 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/basic_parsing_test_bypass.tesh000644 001750 001750 00000020321 12342443664 025433 0ustar00cici000000 000000 #! ./tesh p Testing a bypass ASroute ! output sort $ ${bindir:=.}/basic_parsing_test ${srcdir:=.}/examples/platforms/bypassASroute.xml FULL_LINK > [0.000000] [surf_workstation/INFO] surf_workstation_model_init_ptask_L07 > Workstation number: 3, link number: 11 > Route between 1 and 1 > Route size 2 > Link my_cluster_1_link_1_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link my_cluster_1_link_1_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between 1 and 2 > Route size 1 > Link link_tmp: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.000500, route bandwidth = 1250000000.000000 > Route between 1 and 3 > Route size 4 > Link my_cluster_1_link_1_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link link1: latency = 0.000500, bandwidth = 1250000000.000000 > Link link3: latency = 0.000500, bandwidth = 1250000000.000000 > Link my_cluster_3_link_3_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001100, route bandwidth = 125000000.000000 > Route between 2 and 1 > Route size 4 > Link my_cluster_2_link_2_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link link2: latency = 0.000500, bandwidth = 1250000000.000000 > Link link1: latency = 0.000500, bandwidth = 1250000000.000000 > Link my_cluster_1_link_1_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001100, route bandwidth = 125000000.000000 > Route between 2 and 2 > Route size 2 > Link my_cluster_2_link_2_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link my_cluster_2_link_2_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between 2 and 3 > Route size 4 > Link my_cluster_2_link_2_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link link2: latency = 0.000500, bandwidth = 1250000000.000000 > Link link3: latency = 0.000500, bandwidth = 1250000000.000000 > Link my_cluster_3_link_3_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001100, route bandwidth = 125000000.000000 > Route between 3 and 1 > Route size 4 > Link my_cluster_3_link_3_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link link3: latency = 0.000500, bandwidth = 1250000000.000000 > Link link1: latency = 0.000500, bandwidth = 1250000000.000000 > Link my_cluster_1_link_1_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001100, route bandwidth = 125000000.000000 > Route between 3 and 2 > Route size 4 > Link my_cluster_3_link_3_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link link3: latency = 0.000500, bandwidth = 1250000000.000000 > Link link2: latency = 0.000500, bandwidth = 1250000000.000000 > Link my_cluster_2_link_2_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.001100, route bandwidth = 125000000.000000 > Route between 3 and 3 > Route size 2 > Link my_cluster_3_link_3_UP: latency = 0.000050, bandwidth = 125000000.000000 > Link my_cluster_3_link_3_DOWN: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 p Testing a bypass route $ ${bindir:=.}/basic_parsing_test ${srcdir:=.}/examples/platforms/bypassRoute.xml FULL_LINK > [0.000000] [surf_workstation/INFO] surf_workstation_model_init_ptask_L07 > Workstation number: 4, link number: 10 > Route between AS_2_host1 and AS_2_host1 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between AS_2_host1 and AS_2_host2 > Route size 3 > Link AS_2_link7: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link6: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link5: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.001500, route bandwidth = 1250000000.000000 > Route between AS_2_host1 and AS_2_host3 > Route size 2 > Link AS_2_link1: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link3: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.001000, route bandwidth = 1250000000.000000 > Route between AS_2_host1 and AS_1_host1 > Route size 4 > Link AS_2_link1: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link4: latency = 0.000500, bandwidth = 1250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_1_link: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.002000, route bandwidth = 1250000000.000000 > Route between AS_2_host2 and AS_2_host1 > Route size 2 > Link AS_2_link2: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link1: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.001000, route bandwidth = 1250000000.000000 > Route between AS_2_host2 and AS_2_host2 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between AS_2_host2 and AS_2_host3 > Route size 2 > Link AS_2_link2: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link3: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.001000, route bandwidth = 1250000000.000000 > Route between AS_2_host2 and AS_1_host1 > Route size 4 > Link AS_2_link2: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link4: latency = 0.000500, bandwidth = 1250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_1_link: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.002000, route bandwidth = 1250000000.000000 > Route between AS_2_host3 and AS_2_host1 > Route size 2 > Link AS_2_link3: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link1: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.001000, route bandwidth = 1250000000.000000 > Route between AS_2_host3 and AS_2_host2 > Route size 2 > Link AS_2_link3: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link2: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.001000, route bandwidth = 1250000000.000000 > Route between AS_2_host3 and AS_2_host3 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between AS_2_host3 and AS_1_host1 > Route size 4 > Link AS_2_link3: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link4: latency = 0.000500, bandwidth = 1250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_1_link: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.002000, route bandwidth = 1250000000.000000 > Route between AS_1_host1 and AS_2_host1 > Route size 4 > Link AS_1_link: latency = 0.000500, bandwidth = 1250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link4: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link1: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.002000, route bandwidth = 1250000000.000000 > Route between AS_1_host1 and AS_2_host2 > Route size 4 > Link AS_1_link: latency = 0.000500, bandwidth = 1250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link4: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link2: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.002000, route bandwidth = 1250000000.000000 > Route between AS_1_host1 and AS_2_host3 > Route size 4 > Link AS_1_link: latency = 0.000500, bandwidth = 1250000000.000000 > Link backbone: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link4: latency = 0.000500, bandwidth = 1250000000.000000 > Link AS_2_link3: latency = 0.000500, bandwidth = 1250000000.000000 > Route latency = 0.002000, route bandwidth = 1250000000.000000 > Route between AS_1_host1 and AS_1_host1 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000SimGrid-3.11/teshsuite/simdag/platforms/bob0_state_file.trace000644 001750 001750 00000000052 12342443666 023364 0ustar00cici000000 000000 PERIODICITY 1.0 0.0 1.0 11.0 0.5 20.0 0.8 SimGrid-3.11/teshsuite/simdag/platforms/bob2_availability_file.trace000644 001750 001750 00000000052 12342443666 024720 0ustar00cici000000 000000 PERIODICITY 1.0 0.0 1.0 11.0 0.5 20.0 0.8 SimGrid-3.11/teshsuite/simdag/platforms/two_clusters.xml000644 001750 001750 00000001423 12342443670 022600 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/basic_tracing.c000644 001750 001750 00000002106 12342443665 022260 0ustar00cici000000 000000 /* Copyright (c) 2008-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "msg/msg.h" #include "surf/surf_private.h" int host(int argc, char *argv[]); XBT_LOG_NEW_DEFAULT_CATEGORY(basic_tracing,"Messages specific for this example"); int host(int argc, char *argv[]) { XBT_INFO("Sleep for 1s"); MSG_process_sleep(1); return 0; } int main(int argc, char **argv) { int res; xbt_dynar_t all_hosts; msg_host_t first_host; MSG_init(&argc, argv); MSG_create_environment(argv[1]); MSG_function_register("host", host); all_hosts = MSG_hosts_as_dynar(); first_host = xbt_dynar_pop_as(all_hosts,msg_host_t); MSG_process_create( "host", host, NULL, first_host); xbt_dynar_free(&all_hosts); res = MSG_main(); XBT_INFO("Simulation time %g", MSG_get_clock()); if (res == MSG_OK) return 0; else return 1; } SimGrid-3.11/teshsuite/simdag/platforms/two_hosts_one_link.xml000644 001750 001750 00000000567 12342443670 023762 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/flatifier.c000644 001750 001750 00000021437 12342443665 021445 0ustar00cici000000 000000 /* Copyright (c) 2008-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifndef _XBT_WIN32 #include #endif #include #include #include #include #include #include "simdag/simdag.h" #include "xbt/log.h" #include "xbt/dict.h" #include "xbt/ex.h" #include "xbt/xbt_os_time.h" #include "surf/surf.h" #include "surf/surf_private.h" static const char link_ctn_v2[] = "link:ctn"; static const char link_ctn_v3[] = "link_ctn"; XBT_LOG_NEW_DEFAULT_CATEGORY(flatifier, "Logging specific to this platform parsing tool"); static int name_compare_hosts(const void *n1, const void *n2) { char name1[80], name2[80]; strcpy(name1, SD_workstation_get_name(*((SD_workstation_t *) n1))); strcpy(name2, SD_workstation_get_name(*((SD_workstation_t *) n2))); return strcmp(name1, name2); } static int name_compare_links(const void *n1, const void *n2) { char name1[80], name2[80]; strcpy(name1, SD_link_get_name(*((SD_link_t *) n1))); strcpy(name2, SD_link_get_name(*((SD_link_t *) n2))); return strcmp(name1, name2); } static int parse_cmdline(int *timings, int *downgrade, char **platformFile, int argc, char **argv) { int wrong_option = 0; int i; for (i = 1; i < argc; i++) { if (strlen(argv[i]) > 1 && argv[i][0] == '-' && argv[i][1] == '-') { if (!strcmp(argv[i], "--timings")) { *timings = 1; } else { if (!strcmp(argv[i], "--downgrade")) { *downgrade = 1; } else { wrong_option = 1; break; } } } else { *platformFile = argv[i]; } } return wrong_option; } static void create_environment(xbt_os_timer_t parse_time, const char *platformFile) { xbt_ex_t e; TRY { xbt_os_cputimer_start(parse_time); SD_create_environment(platformFile); xbt_os_cputimer_stop(parse_time); } CATCH(e) { xbt_die("Error while loading %s: %s", platformFile, e.msg); } } int main(int argc, char **argv) { char *platformFile = NULL; int totalHosts, totalLinks; int timings=0; int downgrade = 0; int version = 3; const char *link_ctn = link_ctn_v3; unsigned int i; xbt_dict_t props = NULL; xbt_dict_cursor_t cursor = NULL; xbt_lib_cursor_t cursor_src = NULL; xbt_lib_cursor_t cursor_dst = NULL; char *src,*dst,*key,*data; sg_routing_edge_t value1; sg_routing_edge_t value2; const SD_workstation_t *hosts; const SD_link_t *links; xbt_os_timer_t parse_time = xbt_os_timer_new(); #ifdef _XBT_WIN32 setbuf(stderr, NULL); setbuf(stdout, NULL); #else setvbuf(stdout, NULL, _IOLBF, 0); #endif SD_init(&argc, argv); if (parse_cmdline(&timings, &downgrade, &platformFile, argc, argv) || !platformFile) { xbt_die("Invalid command line arguments: expected [--timings|--downgrade] platformFile"); } XBT_DEBUG("%d,%d,%s", timings, downgrade, platformFile); if (downgrade) { version = 2; link_ctn = link_ctn_v2; } create_environment(parse_time, platformFile); if (timings) { XBT_INFO("Parsing time: %fs (%d hosts, %d links)", xbt_os_timer_elapsed(parse_time),SD_workstation_get_number(),SD_link_get_number()); } else { printf("\n"); printf("\n"); printf("\n", version); if (!downgrade) printf("\n"); // Hosts totalHosts = SD_workstation_get_number(); hosts = SD_workstation_get_list(); qsort((void *) hosts, totalHosts, sizeof(SD_workstation_t), name_compare_hosts); for (i = 0; i < totalHosts; i++) { printf(" 1) { printf(" core=\"%d\"", SD_workstation_get_cores(hosts[i])); } if (props && !xbt_dict_is_empty(props)) { printf(">\n"); xbt_dict_foreach(props, cursor, key, data) { printf(" \n", key, data); } printf(" \n"); } else { printf("/>\n"); } } // Routers xbt_lib_foreach(as_router_lib, cursor_src, key, value1) { if(surf_routing_edge_get_rc_type(xbt_lib_get_or_null(as_router_lib, key, ROUTING_ASR_LEVEL)) == SURF_NETWORK_ELEMENT_ROUTER) { printf(" \n",key); } } // Links totalLinks = SD_link_get_number(); links = SD_link_get_list(); qsort((void *) links, totalLinks, sizeof(SD_link_t), name_compare_links); for (i = 0; i < totalLinks; i++) { printf(" \n"); } else { printf(" sharing_policy=\"FATPIPE\"/>\n"); } } xbt_lib_foreach(host_lib, cursor_src, src, value1) // Routes from host { value1 = xbt_lib_get_or_null(host_lib,src,ROUTING_HOST_LEVEL); xbt_lib_foreach(host_lib, cursor_dst, dst, value2) //to host { printf(" \n " ,src ,dst); xbt_dynar_t route=NULL; value2 = xbt_lib_get_or_null(host_lib,dst,ROUTING_HOST_LEVEL); routing_get_route_and_latency(value1,value2,&route,NULL); for(i=0;i",link_ctn,link_name); free(link_name); } printf("\n \n"); } xbt_lib_foreach(as_router_lib, cursor_dst, dst, value2) //to router { if(routing_get_network_element_type(dst) == SURF_NETWORK_ELEMENT_ROUTER){ printf(" \n " ,src ,dst); xbt_dynar_t route=NULL; value2 = xbt_lib_get_or_null(as_router_lib,dst,ROUTING_ASR_LEVEL); routing_get_route_and_latency((sg_routing_edge_t)value1,(sg_routing_edge_t)value2,&route,NULL); for(i=0;i",link_ctn,link_name); free(link_name); } printf("\n \n"); } } } xbt_lib_foreach(as_router_lib, cursor_src, src, value1) // Routes from router { value1 = xbt_lib_get_or_null(as_router_lib,src,ROUTING_ASR_LEVEL); if(routing_get_network_element_type(src) == SURF_NETWORK_ELEMENT_ROUTER){ xbt_lib_foreach(as_router_lib, cursor_dst, dst, value2) //to router { if(routing_get_network_element_type(dst) == SURF_NETWORK_ELEMENT_ROUTER){ printf(" \n " ,src ,dst); xbt_dynar_t route=NULL; value2 = xbt_lib_get_or_null(as_router_lib,dst,ROUTING_ASR_LEVEL); routing_get_route_and_latency((sg_routing_edge_t)value1,(sg_routing_edge_t)value2,&route,NULL); for(i=0;i",link_ctn,link_name); free(link_name); } printf("\n \n"); } } xbt_lib_foreach(host_lib, cursor_dst, dst, value2) //to host { printf(" \n " ,src, dst); xbt_dynar_t route=NULL; value2 = xbt_lib_get_or_null(host_lib,dst,ROUTING_HOST_LEVEL); routing_get_route_and_latency((sg_routing_edge_t)value1,(sg_routing_edge_t)value2,&route, NULL); for(i=0;i",link_ctn,link_name); free(link_name); } printf("\n \n"); } } } if (!downgrade) printf("\n"); printf("\n"); } SD_exit(); xbt_os_timer_free(parse_time); return 0; } SimGrid-3.11/teshsuite/simdag/platforms/properties.xml000644 001750 001750 00000000724 12342443670 022242 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/three_hosts_non_symmetric_route.xml000644 001750 001750 00000001452 12342443670 026560 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/bob0_availability_file.trace000644 001750 001750 00000000052 12342443666 024716 0ustar00cici000000 000000 PERIODICITY 1.0 0.0 1.0 11.0 0.5 20.0 0.8 SimGrid-3.11/teshsuite/simdag/platforms/one_cluster_multicore.xml000644 001750 001750 00000000451 12342443670 024450 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/bogus_missing_dst_gateway.xml000644 001750 001750 00000001433 12342443670 025307 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/Dijkstra.xml000644 001750 001750 00000001751 12342443670 021622 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/two_clusters_router_id.xml000644 001750 001750 00000001734 12342443670 024661 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_host.xml000644 001750 001750 00000000313 12342443670 021656 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_link_availability.xml000644 001750 001750 00000000476 12342443670 024402 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_link_fatpipe.xml000644 001750 001750 00000000444 12342443670 023353 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/four_hosts_floyd_ns3.xml000644 001750 001750 00000001373 12342443670 024222 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_cluster.xml000644 001750 001750 00000000503 12342443670 022363 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/get_full_link.tesh000644 001750 001750 00000020577 12342443664 023042 0ustar00cici000000 000000 #! ./tesh ! output sort $ ${bindir:=.}/basic_parsing_test ./four_hosts_floyd.xml FULL_LINK > [0.000000] [surf_workstation/INFO] surf_workstation_model_init_ptask_L07 > Workstation number: 4, link number: 5 > Route between host1 and host1 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between host1 and host2 > Route size 1 > Link link1: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host1 and host3 > Route size 1 > Link link2: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host1 and host4 > Route size 2 > Link link2: latency = 0.000050, bandwidth = 125000000.000000 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between host2 and host1 > Route size 1 > Link link1: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host2 and host2 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between host2 and host3 > Route size 1 > Link link3: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host2 and host4 > Route size 2 > Link link3: latency = 0.000050, bandwidth = 125000000.000000 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between host3 and host1 > Route size 1 > Link link2: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host3 and host2 > Route size 1 > Link link3: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host3 and host3 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between host3 and host4 > Route size 1 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host4 and host1 > Route size 2 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Link link2: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between host4 and host2 > Route size 2 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Link link3: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between host4 and host3 > Route size 1 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host4 and host4 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 $ ${bindir:=.}/basic_parsing_test ./four_hosts_floyd_bis.xml FULL_LINK > [0.000000] [surf_workstation/INFO] surf_workstation_model_init_ptask_L07 > Workstation number: 5, link number: 7 > Route between host1 and host1 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between host1 and host2 > Route size 1 > Link link1: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host1 and host3 > Route size 1 > Link link2: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host1 and host4 > Route size 2 > Link link2: latency = 0.000050, bandwidth = 125000000.000000 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between host1 and host5 > Route size 2 > Link link1: latency = 0.000050, bandwidth = 125000000.000000 > Link link5: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between host2 and host1 > Route size 1 > Link link1: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host2 and host2 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between host2 and host3 > Route size 1 > Link link3: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host2 and host4 > Route size 2 > Link link3: latency = 0.000050, bandwidth = 125000000.000000 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between host2 and host5 > Route size 1 > Link link5: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host3 and host1 > Route size 1 > Link link2: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host3 and host2 > Route size 1 > Link link3: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host3 and host3 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between host3 and host4 > Route size 1 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host3 and host5 > Route size 1 > Link link6: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host4 and host1 > Route size 2 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Link link2: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between host4 and host2 > Route size 2 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Link link3: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between host4 and host3 > Route size 1 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host4 and host4 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000 > Route between host4 and host5 > Route size 2 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Link link6: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between host5 and host1 > Route size 2 > Link link5: latency = 0.000050, bandwidth = 125000000.000000 > Link link1: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between host5 and host2 > Route size 1 > Link link5: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host5 and host3 > Route size 1 > Link link6: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000050, route bandwidth = 125000000.000000 > Route between host5 and host4 > Route size 2 > Link link6: latency = 0.000050, bandwidth = 125000000.000000 > Link link4: latency = 0.000050, bandwidth = 125000000.000000 > Route latency = 0.000100, route bandwidth = 125000000.000000 > Route between host5 and host5 > Route size 1 > Link __loopback__: latency = 0.000015, bandwidth = 498000000.000000 > Route latency = 0.000015, route bandwidth = 498000000.000000SimGrid-3.11/teshsuite/simdag/platforms/bogus_two_hosts_asymetric.xml000644 001750 001750 00000001306 12342443670 025353 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_cluster_foreach.xml000644 001750 001750 00000001231 12342443670 024051 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/bogus_missing_src_gateway.xml000644 001750 001750 00000001433 12342443670 025304 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/route_override.xml000644 001750 001750 00000002114 12342443670 023076 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_cluster_properties_foreach.xml000644 001750 001750 00000000655 12342443670 026336 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_host_availability.xml000644 001750 001750 00000000361 12342443670 024413 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/one_host_trace_inside.xml000644 001750 001750 00000000541 12342443670 024372 0ustar00cici000000 000000 0.0 1.0 11.0 0.5 20.0 0.8 SimGrid-3.11/teshsuite/simdag/platforms/link1.lat000644 001750 001750 00000000055 12342443666 021046 0ustar00cici000000 000000 PERIODICITY 5.0 1.0 0.001 2.0 0.01 3.0 0.001 SimGrid-3.11/teshsuite/simdag/platforms/basic_parsing_test_failing.tesh000644 001750 001750 00000000747 12342443664 025555 0ustar00cici000000 000000 ! output sort $ ${bindir:=.}/simdag/platforms/basic_parsing_test --cfg=path:simdag/platforms one_cluster_properties_override.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'path' to 'simdag/platforms' ! output sort $ ${bindir:=.}/simdag/platforms/basic_parsing_test --cfg=path:simdag/platforms one_host_trace_file.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n" > [ 0.000000] (0:@) Configuration change: Set 'path' to 'simdag/platforms' SimGrid-3.11/teshsuite/simdag/platforms/one_link_shared.xml000644 001750 001750 00000000401 12342443670 023162 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/platforms/CMakeLists.txt000644 001750 001750 00000012270 12342443654 022065 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(basic_parsing_test basic_parsing_test.c) add_executable(is_router_test is_router_test.c) add_executable(flatifier flatifier.c) add_executable(basic_tracing basic_tracing.c) add_executable(basic_link_test basic_link_test.c) ### Add definitions for compile if(NOT WIN32) add_executable(evaluate_parse_time Evaluate_parse_time.c) add_executable(evaluate_get_route_time Evaluate_get_route_time.c) target_link_libraries(evaluate_get_route_time simgrid m) target_link_libraries(evaluate_parse_time simgrid m) target_link_libraries(basic_parsing_test simgrid m) target_link_libraries(is_router_test simgrid m) target_link_libraries(flatifier simgrid m) target_link_libraries(basic_tracing simgrid m) target_link_libraries(basic_link_test simgrid m) else() target_link_libraries(basic_parsing_test simgrid) target_link_libraries(is_router_test simgrid) target_link_libraries(flatifier simgrid) target_link_libraries(basic_tracing simgrid) target_link_libraries(basic_link_test simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/basic_parsing_test_failing.tesh ${CMAKE_CURRENT_SOURCE_DIR}/basic_parsing_test_sym_full.tesh ${CMAKE_CURRENT_SOURCE_DIR}/basic_parsing_test.tesh ${CMAKE_CURRENT_SOURCE_DIR}/basic_parsing_test_bypass.tesh ${CMAKE_CURRENT_SOURCE_DIR}/basic_link_test.tesh ${CMAKE_CURRENT_SOURCE_DIR}/flatifier.tesh ${CMAKE_CURRENT_SOURCE_DIR}/get_full_link.tesh ${CMAKE_CURRENT_SOURCE_DIR}/bogus_two_hosts_asymetric.tesh ${CMAKE_CURRENT_SOURCE_DIR}/bogus_missing_gateway.tesh ${CMAKE_CURRENT_SOURCE_DIR}/bogus_disk_attachment.tesh PARENT_SCOPE ) set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/four_hosts_Dijkstra_ns3.xml ${CMAKE_CURRENT_SOURCE_DIR}/four_hosts_floyd_bis.xml ${CMAKE_CURRENT_SOURCE_DIR}/four_hosts_floyd_ns3.xml ${CMAKE_CURRENT_SOURCE_DIR}/four_hosts_floyd.xml ${CMAKE_CURRENT_SOURCE_DIR}/two_hosts_multi_hop.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_cluster_file.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_cluster_multicore.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_cluster_foreach.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_cluster_fullduplex.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_cluster_one_host_random.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_cluster_one_host.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_cluster_properties_foreach.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_cluster_properties_override.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_cluster_router_id.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_cluster.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_host_availability.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_host_properties.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_host_state_file.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_host_state_off.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_host_state_on.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_host_trace_file.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_host_trace_inside.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_host.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_link_availability.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_link_fatpipe.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_link_shared.xml ${CMAKE_CURRENT_SOURCE_DIR}/one_link_state_file.xml ${CMAKE_CURRENT_SOURCE_DIR}/platform_include.xml ${CMAKE_CURRENT_SOURCE_DIR}/properties.xml ${CMAKE_CURRENT_SOURCE_DIR}/random.xml ${CMAKE_CURRENT_SOURCE_DIR}/route_override.xml ${CMAKE_CURRENT_SOURCE_DIR}/test_of_is_router.xml ${CMAKE_CURRENT_SOURCE_DIR}/three_hosts_non_symmetric_route.xml ${CMAKE_CURRENT_SOURCE_DIR}/two_clusters_one_name.xml ${CMAKE_CURRENT_SOURCE_DIR}/two_clusters_router_id.xml ${CMAKE_CURRENT_SOURCE_DIR}/two_clusters_symmetric.xml ${CMAKE_CURRENT_SOURCE_DIR}/two_clusters.xml ${CMAKE_CURRENT_SOURCE_DIR}/bogus_missing_src_gateway.xml ${CMAKE_CURRENT_SOURCE_DIR}/bogus_missing_dst_gateway.xml ${CMAKE_CURRENT_SOURCE_DIR}/bogus_two_hosts_asymetric.xml ${CMAKE_CURRENT_SOURCE_DIR}/bogus_two_hosts_asymetric-2.xml ${CMAKE_CURRENT_SOURCE_DIR}/two_hosts_one_link_fullduplex.xml ${CMAKE_CURRENT_SOURCE_DIR}/two_hosts_one_link_symmetrical.xml ${CMAKE_CURRENT_SOURCE_DIR}/two_hosts_one_link.xml ${CMAKE_CURRENT_SOURCE_DIR}/clusterA.xml ${CMAKE_CURRENT_SOURCE_DIR}/clusterB.xml ${CMAKE_CURRENT_SOURCE_DIR}/Dijkstra.xml ${CMAKE_CURRENT_SOURCE_DIR}/bogus_disk_attachment.xml PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/basic_parsing_test.c ${CMAKE_CURRENT_SOURCE_DIR}/basic_tracing.c ${CMAKE_CURRENT_SOURCE_DIR}/basic_link_test.c ${CMAKE_CURRENT_SOURCE_DIR}/Evaluate_get_route_time.c ${CMAKE_CURRENT_SOURCE_DIR}/Evaluate_parse_time.c ${CMAKE_CURRENT_SOURCE_DIR}/flatifier.c ${CMAKE_CURRENT_SOURCE_DIR}/is_router_test.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/bob0_availability_file.trace ${CMAKE_CURRENT_SOURCE_DIR}/bob0_state_file.trace ${CMAKE_CURRENT_SOURCE_DIR}/bob2_availability_file.trace ${CMAKE_CURRENT_SOURCE_DIR}/bob2_state_file.trace ${CMAKE_CURRENT_SOURCE_DIR}/bob.fail ${CMAKE_CURRENT_SOURCE_DIR}/bob.trace ${CMAKE_CURRENT_SOURCE_DIR}/link1.bw ${CMAKE_CURRENT_SOURCE_DIR}/link1.fail ${CMAKE_CURRENT_SOURCE_DIR}/link1.lat PARENT_SCOPE ) SimGrid-3.11/teshsuite/simdag/incomplete/000755 001750 001750 00000000000 12342443665 017455 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/simdag/incomplete/incomplete.c000644 001750 001750 00000004455 12342443665 021770 0ustar00cici000000 000000 /* Copyright (c) 2007-2012, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include "simdag/simdag.h" #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(incomplete, sd, "SimDag incomplete test"); /* SimDag Incomplete Test * Scenario: * - Create a bunch of tasks * - schedule only a subset of them (init, A and D) * - run the simulation * - Verify that we detect which tasks are not scheduled and show their state. * The scheduled task A sends 1GB. Simulation time should be * 1e9/1.25e8 + 1e-4 = 8.0001 seconds * Task D is scheduled but depends on unscheduled task C. */ int main(int argc, char **argv) { SD_task_t taskInit; SD_task_t taskA, taskB, taskC, taskD; xbt_dynar_t ret; const SD_workstation_t *workstation; double communication_amount1 = 1e9; double no_cost = 0.0; /* initialization of SD */ SD_init(&argc, argv); /* creation of the environment */ SD_create_environment(argv[1]); /* creation of the tasks and their dependencies */ taskInit = SD_task_create("Init", NULL, 1.0); taskA = SD_task_create("Task A", NULL, 1.0); taskB = SD_task_create("Task B", NULL, 1.0); taskC = SD_task_create("Task C", NULL, 1.0); taskD = SD_task_create("Task D", NULL, 1.0); /* scheduling parameters */ workstation = SD_workstation_get_list(); SD_task_dependency_add(NULL, NULL, taskInit, taskA); SD_task_dependency_add(NULL, NULL, taskInit, taskB); SD_task_dependency_add(NULL, NULL, taskC, taskD); /* let's launch the simulation! */ SD_task_schedule(taskInit, 1, SD_workstation_get_list(), &no_cost, &no_cost, -1.0); SD_task_schedule(taskA, 1, &workstation[0], &no_cost, &communication_amount1, -1.0); SD_task_schedule(taskD, 1, &workstation[0], &no_cost, &communication_amount1, -1.0); ret = SD_simulate(-1.); xbt_dynar_free(&ret); SD_task_destroy(taskA); SD_task_destroy(taskB); SD_task_destroy(taskC); SD_task_destroy(taskD); SD_task_destroy(taskInit); XBT_INFO("Simulation time: %f", SD_get_clock()); SD_exit(); return 0; } SimGrid-3.11/teshsuite/simdag/incomplete/incomplete.tesh000644 001750 001750 00000000614 12342443664 022501 0ustar00cici000000 000000 $ ${bindir:=.}/incomplete ../basic/basic_platform.xml "--log=root.fmt:[%10.6r]%e%m%n" > [ 0.000000] surf_workstation_model_init_ptask_L07 > [ 8.000100] Simulation is finished but 3 tasks are still not done > [ 8.000100] Task C is in SD_NOT_SCHEDULED state > [ 8.000100] Task B is in SD_SCHEDULABLE state > [ 8.000100] Task D is in SD_SCHEDULED state > [ 8.000100] Simulation time: 8.000100 SimGrid-3.11/teshsuite/simdag/incomplete/CMakeLists.txt000644 001750 001750 00000001175 12342443654 022217 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(incomplete incomplete.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(incomplete simgrid m pthread ) else() target_link_libraries(incomplete simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/incomplete.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(teshsuite_src ${teshsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/incomplete.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/surf/000755 001750 001750 00000000000 12342443670 015025 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/surf/surf_usage/000755 001750 001750 00000000000 12342443665 017174 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/surf/surf_usage/surf_usage.tesh000644 001750 001750 00000001250 12342443665 022222 0ustar00cici000000 000000 #! ./tesh $ $SG_TEST_EXENV ${bindir:=.}/surf_usage platform.xml > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'cpu/model' to 'Cas01' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'CM02' > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) $ $SG_TEST_EXENV ${bindir:=.}/surf_usage2 platform.xml > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'CM02' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'cpu/model' to 'Cas01' > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s) SimGrid-3.11/teshsuite/surf/surf_usage/surf_usage.c000644 001750 001750 00000011526 12342443665 021510 0ustar00cici000000 000000 /* A few basic tests for the surf library */ /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifdef __BORLANDC__ #pragma hdrstop #endif #include #include "simgrid/sg_config.h" #include "surf/surf.h" #include "surf/surf_resource.h" #include "surf/surfxml_parse.h" // for reset callback #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_CATEGORY(surf_test, "Messages specific for surf example"); const char *string_action(e_surf_action_state_t state); const char *string_action(e_surf_action_state_t state) { switch (state) { case (SURF_ACTION_READY): return "SURF_ACTION_READY"; case (SURF_ACTION_RUNNING): return "SURF_ACTION_RUNNING"; case (SURF_ACTION_FAILED): return "SURF_ACTION_FAILED"; case (SURF_ACTION_DONE): return "SURF_ACTION_DONE"; case (SURF_ACTION_NOT_IN_THE_SYSTEM): return "SURF_ACTION_NOT_IN_THE_SYSTEM"; default: return "INVALID STATE"; } } void test(char *platform); void test(char *platform) { void *cpuA = NULL; void *cpuB = NULL; void *cardA = NULL; void *cardB = NULL; surf_action_t actionA = NULL; surf_action_t actionB = NULL; surf_action_t actionC = NULL; e_surf_action_state_t stateActionA; e_surf_action_state_t stateActionB; e_surf_action_state_t stateActionC; double now = -1.0; xbt_cfg_set_parse(_sg_cfg_set, "cpu/model:Cas01"); xbt_cfg_set_parse(_sg_cfg_set, "network/model:CM02"); parse_platform_file(platform); /*********************** CPU ***********************************/ XBT_DEBUG("%p", surf_cpu_model_pm); cpuA = surf_cpu_resource_by_name("Cpu A"); cpuB = surf_cpu_resource_by_name("Cpu B"); /* Let's check that those two processors exist */ XBT_DEBUG("%s : %p", surf_resource_name(surf_cpu_resource_priv(cpuA)), cpuA); XBT_DEBUG("%s : %p", surf_resource_name(surf_cpu_resource_priv(cpuB)), cpuB); /* Let's do something on it */ actionA = surf_cpu_execute(cpuA, 1000.0); actionB = surf_cpu_execute(cpuB, 1000.0); actionC = surf_cpu_sleep(cpuB, 7.32); /* Use whatever calling style you want... */ stateActionA = surf_action_get_state(actionA); /* When you know actionA model type */ stateActionB = surf_action_get_state(actionB); /* If you're unsure about it's model type */ stateActionC = surf_action_get_state(actionC); /* When you know actionA model type */ /* And just look at the state of these tasks */ XBT_DEBUG("actionA : %p (%s)", actionA, string_action(stateActionA)); XBT_DEBUG("actionB : %p (%s)", actionB, string_action(stateActionB)); XBT_DEBUG("actionC : %p (%s)", actionB, string_action(stateActionC)); /*********************** Network *******************************/ XBT_DEBUG("%p", surf_network_model); cardA = sg_routing_edge_by_name_or_null("Cpu A"); cardB = sg_routing_edge_by_name_or_null("Cpu B"); /* Let's check that those two processors exist */ XBT_DEBUG("%s : %p", surf_routing_edge_name(cardA), cardA); XBT_DEBUG("%s : %p", surf_routing_edge_name(cardB), cardB); /* Let's do something on it */ surf_network_model_communicate(surf_network_model, cardA, cardB, 150.0, -1.0); surf_solve(-1.0); /* Takes traces into account. Returns 0.0 */ do { surf_action_t action = NULL; now = surf_get_clock(); XBT_DEBUG("Next Event : %g", now); XBT_DEBUG("\t CPU actions"); while ((action = surf_model_extract_failed_action_set((surf_model_t)surf_cpu_model_pm))) { XBT_DEBUG("\t * Failed : %p", action); surf_action_unref(action); } while ((action = surf_model_extract_done_action_set((surf_model_t)surf_cpu_model_pm))) { XBT_DEBUG("\t * Done : %p", action); surf_action_unref(action); } XBT_DEBUG("\t Network actions"); while ((action = surf_model_extract_failed_action_set((surf_model_t)surf_network_model))) { XBT_DEBUG("\t * Failed : %p", action); surf_action_unref(action); } while ((action = surf_model_extract_done_action_set((surf_model_t)surf_network_model))) { XBT_DEBUG("\t * Done : %p", action); surf_action_unref(action); } } while ((surf_model_running_action_set_size((surf_model_t)surf_network_model) || surf_model_running_action_set_size((surf_model_t)surf_cpu_model_pm)) && surf_solve(-1.0) >= 0.0); XBT_DEBUG("Simulation Terminated"); } #ifdef __BORLANDC__ #pragma argsused #endif int main(int argc, char **argv) { surf_init(&argc, argv); /* Initialize some common structures */ if (argc == 1) { fprintf(stderr, "Usage : %s platform.xml\n", argv[0]); return 1; } test(argv[1]); surf_exit(); return 0; } SimGrid-3.11/teshsuite/surf/surf_usage/surf_usage2.c000644 001750 001750 00000006610 12342443666 021571 0ustar00cici000000 000000 /* A few basic tests for the surf library */ /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifdef __BORLANDC__ #pragma hdrstop #endif #include #include "simgrid/sg_config.h" #include "surf/surf.h" #include "surf/surf_resource.h" #include "surf/surfxml_parse.h" // for reset callback #include "xbt/log.h" XBT_LOG_NEW_DEFAULT_CATEGORY(surf_test, "Messages specific for surf example"); const char *string_action(e_surf_action_state_t state); const char *string_action(e_surf_action_state_t state) { switch (state) { case (SURF_ACTION_READY): return "SURF_ACTION_READY"; case (SURF_ACTION_RUNNING): return "SURF_ACTION_RUNNING"; case (SURF_ACTION_FAILED): return "SURF_ACTION_FAILED"; case (SURF_ACTION_DONE): return "SURF_ACTION_DONE"; case (SURF_ACTION_NOT_IN_THE_SYSTEM): return "SURF_ACTION_NOT_IN_THE_SYSTEM"; default: return "INVALID STATE"; } } void test(char *platform); void test(char *platform) { void *workstationA = NULL; void *workstationB = NULL; double now = -1.0; int running; xbt_cfg_set_parse(_sg_cfg_set, "network/model:CM02"); xbt_cfg_set_parse(_sg_cfg_set, "cpu/model:Cas01"); parse_platform_file(platform); /*********************** WORKSTATION ***********************************/ workstationA = surf_workstation_resource_by_name("Cpu A"); workstationB = surf_workstation_resource_by_name("Cpu B"); /* Let's check that those two processors exist */ XBT_DEBUG("%s : %p", surf_resource_name(workstationA), workstationA); XBT_DEBUG("%s : %p", surf_resource_name(workstationB), workstationB); /* Let's do something on it */ surf_workstation_execute(workstationA, 1000.0); surf_workstation_execute(workstationB, 1000.0); surf_workstation_sleep(workstationB, 7.32); surf_workstation_model_communicate(surf_workstation_model, workstationA, workstationB, 150.0, -1.0); surf_solve(-1.0); /* Takes traces into account. Returns 0.0 */ do { surf_action_t action = NULL; unsigned int iter; surf_model_t model = NULL; running = 0; now = surf_get_clock(); XBT_DEBUG("Next Event : %g", now); xbt_dynar_foreach(model_list, iter, model) { XBT_DEBUG("\t %s actions", surf_model_name(model)); while ((action = surf_model_extract_failed_action_set((surf_model_t)model))) { XBT_DEBUG("\t * Failed : %p", action); surf_action_unref(action); } while ((action = surf_model_extract_done_action_set((surf_model_t)model))) { XBT_DEBUG("\t * Done : %p", action); surf_action_unref(action); } if (surf_model_running_action_set_size((surf_model_t)model)) { XBT_DEBUG("running %s", surf_model_name(model)); running = 1; } } } while (running && surf_solve(-1.0) >= 0.0); XBT_DEBUG("Simulation Terminated"); } #ifdef __BORLANDC__ #pragma argsused #endif int main(int argc, char **argv) { surf_init(&argc, argv); /* Initialize some common structures */ if (argc == 1) { fprintf(stderr, "Usage : %s platform.txt\n", argv[0]); surf_exit(); return 1; } test(argv[1]); surf_exit(); return 0; } SimGrid-3.11/teshsuite/surf/surf_usage/CMakeLists.txt000644 001750 001750 00000001616 12342443654 021736 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(surf_usage ${CMAKE_HOME_DIRECTORY}/teshsuite/surf/surf_usage/surf_usage.c) add_executable(surf_usage2 ${CMAKE_HOME_DIRECTORY}/teshsuite/surf/surf_usage/surf_usage2.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(surf_usage simgrid m ) target_link_libraries(surf_usage2 simgrid m ) else() target_link_libraries(surf_usage simgrid ) target_link_libraries(surf_usage2 simgrid ) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/surf_usage.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(testsuite_src ${testsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/surf_usage.c ${CMAKE_CURRENT_SOURCE_DIR}/surf_usage2.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/surf/lmm_usage/000755 001750 001750 00000000000 12342443665 017002 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/surf/lmm_usage/lmm_usage.tesh000644 001750 001750 00000001103 12342443665 021633 0ustar00cici000000 000000 #! ./tesh $ $SG_TEST_EXENV ${bindir:=.}/lmm_usage > [0.000000] [surf_test/INFO] ***** Test 1 (Max-Min) > [0.000000] [surf_test/INFO] ***** Test 1 (Lagrange - Vegas) > [0.000000] [surf_test/INFO] ***** Test 1 (Lagrange - Reno) > [0.000000] [surf_test/INFO] ***** Test 2 (Max-Min) > [0.000000] [surf_test/INFO] ***** Test 2 (Lagrange - Vegas) > [0.000000] [surf_test/INFO] ***** Test 2 (Lagrange - Reno) > [0.000000] [surf_test/INFO] ***** Test 3 (Max-Min) > [0.000000] [surf_test/INFO] ***** Test 3 (Lagrange - Vegas) > [0.000000] [surf_test/INFO] ***** Test 3 (Lagrange - Reno) SimGrid-3.11/teshsuite/surf/lmm_usage/lmm_usage.c000644 001750 001750 00000031340 12342443665 021120 0ustar00cici000000 000000 /* A few tests for the maxmin library */ /* Copyright (c) 2007-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifdef __BORLANDC__ #pragma hdrstop #endif #include "xbt/sysdep.h" #include "surf/maxmin.h" #include "xbt/log.h" #include "xbt/module.h" #include XBT_LOG_NEW_DEFAULT_CATEGORY(surf_test, "Messages specific for surf example"); #define PRINT_VAR(var) XBT_DEBUG(#var " = %g",lmm_variable_getvalue(var)); #define SHOW_EXPR(expr) XBT_DEBUG(#expr " = %g",expr); /* */ /* ______ */ /* ==l1== L2 ==L3== */ /* ------ */ /* */ typedef enum { MAXMIN, LAGRANGE_RENO, LAGRANGE_VEGAS } method_t; static double dichotomy(double func(double), double min, double max, double min_error) { double middle; double min_func, max_func, middle_func; double overall_error = 2 * min_error; min_func = func(min); max_func = func(max); if ((min_func > 0 && max_func > 0)) return min - 1.0; if ((min_func < 0 && max_func < 0)) return max + 1.0; if ((min_func > 0 && max_func < 0)) abort(); SHOW_EXPR(min_error); while (overall_error > min_error) { SHOW_EXPR(overall_error); if ((min_func > 0 && max_func > 0) || (min_func < 0 && max_func < 0) || (min_func > 0 && max_func < 0)) { abort(); } SHOW_EXPR(min); SHOW_EXPR(min_func); SHOW_EXPR(max); SHOW_EXPR(max_func); middle = (max + min) / 2.0; if ((min == middle) || (max == middle)) { break; } middle_func = func(middle); SHOW_EXPR(middle); SHOW_EXPR(middle_func); if (middle_func < 0) { min = middle; min_func = middle_func; overall_error = max_func - middle_func; } else if (middle_func > 0) { max = middle; max_func = middle_func; overall_error = middle_func - min_func; } else { overall_error = 0; } } return ((min + max) / 2.0); } double a_test_1 = 0; double b_test_1 = 0; static double diff_lagrange_test_1(double x) { return -(3 / (1 + 3 * x * x / 2) - 3 / (2 * (3 * (a_test_1 - x) * (a_test_1 - x) / 2 + 1)) + 3 / (2 * (3 * (b_test_1 - a_test_1 + x) * (b_test_1 - a_test_1 + x) / 2 + 1))); } void test1(method_t method); void test1(method_t method) { lmm_system_t Sys = NULL; lmm_constraint_t L1 = NULL; lmm_constraint_t L2 = NULL; lmm_constraint_t L3 = NULL; lmm_variable_t R_1_2_3 = NULL; lmm_variable_t R_1 = NULL; lmm_variable_t R_2 = NULL; lmm_variable_t R_3 = NULL; double a = 1.0, b = 10.0; if (method == LAGRANGE_VEGAS) lmm_set_default_protocol_function(func_vegas_f, func_vegas_fp, func_vegas_fpi); else if (method == LAGRANGE_RENO) lmm_set_default_protocol_function(func_reno_f, func_reno_fpi, func_reno_fpi); Sys = lmm_system_new(1); L1 = lmm_constraint_new(Sys, (void *) "L1", a); L2 = lmm_constraint_new(Sys, (void *) "L2", b); L3 = lmm_constraint_new(Sys, (void *) "L3", a); R_1_2_3 = lmm_variable_new(Sys, (void *) "R 1->2->3", 1.0, -1.0, 3); R_1 = lmm_variable_new(Sys, (void *) "R 1", 1.0, -1.0, 1); R_2 = lmm_variable_new(Sys, (void *) "R 2", 1.0, -1.0, 1); R_3 = lmm_variable_new(Sys, (void *) "R 3", 1.0, -1.0, 1); lmm_update_variable_weight(Sys, R_1_2_3, 1.0); lmm_update_variable_weight(Sys, R_1, 1.0); lmm_update_variable_weight(Sys, R_2, 1.0); lmm_update_variable_weight(Sys, R_3, 1.0); lmm_expand(Sys, L1, R_1_2_3, 1.0); lmm_expand(Sys, L2, R_1_2_3, 1.0); lmm_expand(Sys, L3, R_1_2_3, 1.0); lmm_expand(Sys, L1, R_1, 1.0); lmm_expand(Sys, L2, R_2, 1.0); lmm_expand(Sys, L3, R_3, 1.0); if (method == MAXMIN) { lmm_solve(Sys); } else if (method == LAGRANGE_VEGAS) { double x = 3 * a / 4 - 3 * b / 8 + sqrt(9 * b * b + 4 * a * a - 4 * a * b) / 8; /* Computed with mupad and D_f=1.0 */ double max_deviation = 0.0; if (x > a) { x = a; } if (x < 0) { x = 0; } lagrange_solve(Sys); max_deviation = MAX(max_deviation, fabs(lmm_variable_getvalue(R_1) - x)); max_deviation = MAX(max_deviation, fabs(lmm_variable_getvalue(R_3) - x)); max_deviation = MAX(max_deviation, fabs(lmm_variable_getvalue(R_2) - (b - a + x))); max_deviation = MAX(max_deviation, fabs(lmm_variable_getvalue(R_1_2_3) - (a - x))); if (max_deviation > 0.00001) { // Legacy value used in lagrange.c XBT_WARN("Max Deviation from optimal solution : %g", max_deviation); XBT_WARN("Found x = %1.20f", x); XBT_WARN("Deviation from optimal solution (R_1 = %g): %1.20f", x, lmm_variable_getvalue(R_1) - x); XBT_WARN("Deviation from optimal solution (R_2 = %g): %1.20f", b - a + x, lmm_variable_getvalue(R_2) - (b - a + x)); XBT_WARN("Deviation from optimal solution (R_3 = %g): %1.20f", x, lmm_variable_getvalue(R_3) - x); XBT_WARN("Deviation from optimal solution (R_1_2_3 = %g): %1.20f", a - x, lmm_variable_getvalue(R_1_2_3) - (a - x)); } } else if (method == LAGRANGE_RENO) { double x; double max_deviation = 0.0; a_test_1 = a; b_test_1 = b; x = dichotomy(diff_lagrange_test_1, 0, a, 1e-13); if (x < 0) x = 0; if (x > a) x = a; lagrange_solve(Sys); max_deviation = MAX(max_deviation, fabs(lmm_variable_getvalue(R_1) - x)); max_deviation = MAX(max_deviation, fabs(lmm_variable_getvalue(R_3) - x)); max_deviation = MAX(max_deviation, fabs(lmm_variable_getvalue(R_2) - (b - a + x))); max_deviation = MAX(max_deviation, fabs(lmm_variable_getvalue(R_1_2_3) - (a - x))); if (max_deviation > 0.00001) { // Legacy value used in lagrange.c XBT_WARN("Max Deviation from optimal solution : %g", max_deviation); XBT_WARN("Found x = %1.20f", x); XBT_WARN("Deviation from optimal solution (R_1 = %g): %1.20f", x, lmm_variable_getvalue(R_1) - x); XBT_WARN("Deviation from optimal solution (R_2 = %g): %1.20f", b - a + x, lmm_variable_getvalue(R_2) - (b - a + x)); XBT_WARN("Deviation from optimal solution (R_3 = %g): %1.20f", x, lmm_variable_getvalue(R_3) - x); XBT_WARN("Deviation from optimal solution (R_1_2_3 = %g): %1.20f", a - x, lmm_variable_getvalue(R_1_2_3) - (a - x)); } } else { xbt_die( "Invalid method"); } PRINT_VAR(R_1_2_3); PRINT_VAR(R_1); PRINT_VAR(R_2); PRINT_VAR(R_3); lmm_variable_free(Sys, R_1_2_3); lmm_variable_free(Sys, R_1); lmm_variable_free(Sys, R_2); lmm_variable_free(Sys, R_3); lmm_system_free(Sys); } void test2(method_t method); void test2(method_t method) { lmm_system_t Sys = NULL; lmm_constraint_t CPU1 = NULL; lmm_constraint_t CPU2 = NULL; lmm_variable_t T1 = NULL; lmm_variable_t T2 = NULL; if (method == LAGRANGE_VEGAS) lmm_set_default_protocol_function(func_vegas_f, func_vegas_fp, func_vegas_fpi); else if (method == LAGRANGE_RENO) lmm_set_default_protocol_function(func_reno_f, func_reno_fp, func_reno_fpi); Sys = lmm_system_new(1); CPU1 = lmm_constraint_new(Sys, (void *) "CPU1", 200.0); CPU2 = lmm_constraint_new(Sys, (void *) "CPU2", 100.0); T1 = lmm_variable_new(Sys, (void *) "T1", 1.0, -1.0, 1); T2 = lmm_variable_new(Sys, (void *) "T2", 1.0, -1.0, 1); lmm_update_variable_weight(Sys, T1, 1.0); lmm_update_variable_weight(Sys, T2, 1.0); lmm_expand(Sys, CPU1, T1, 1.0); lmm_expand(Sys, CPU2, T2, 1.0); if (method == MAXMIN) { lmm_solve(Sys); } else if (method == LAGRANGE_VEGAS) { lagrange_solve(Sys); } else if (method == LAGRANGE_RENO) { lagrange_solve(Sys); } else { xbt_die("Invalid method"); } PRINT_VAR(T1); PRINT_VAR(T2); lmm_variable_free(Sys, T1); lmm_variable_free(Sys, T2); lmm_system_free(Sys); } void test3(method_t method); void test3(method_t method) { int flows = 11; int links = 10; int i = 0; int j = 0; double **A; lmm_system_t Sys = NULL; lmm_constraint_t *tmp_cnst = NULL; lmm_variable_t *tmp_var = NULL; char **tmp_name; /*array to add the the constraints of fictiv variables */ double B[15] = { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1, 1, 1, 1, 1 }; A = xbt_new0(double *, links + 5); for (i = 0; i < links + 5; i++) { A[i] = xbt_new0(double, flows + 5); for (j = 0; j < flows + 5; j++) { A[i][j] = 0.0; if (i >= links || j >= flows) { A[i][j] = 0.0; } } } /*matrix that store the constraints/topollogy */ /*double A[15][16]= {{0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0}, {0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0}, {1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0}, {1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1} }; */ A[0][1] = 1.0; A[0][7] = 1.0; A[1][1] = 1.0; A[1][7] = 1.0; A[1][8] = 1.0; A[2][1] = 1.0; A[2][8] = 1.0; A[2][1] = 1.0; A[2][8] = 1.0; A[3][8] = 1.0; A[4][0] = 1.0; A[4][3] = 1.0; A[4][9] = 1.0; A[5][0] = 1.0; A[5][3] = 1.0; A[5][4] = 1.0; A[5][9] = 1.0; A[6][0] = 1.0; A[6][4] = 1.0; A[6][9] = 1.0; A[6][10] = 1.0; A[7][2] = 1.0; A[7][4] = 1.0; A[7][6] = 1.0; A[7][9] = 1.0; A[7][10] = 1.0; A[8][2] = 1.0; A[8][10] = 1.0; A[9][5] = 1.0; A[9][6] = 1.0; A[9][9] = 1.0; A[10][11] = 1.0; A[11][12] = 1.0; A[12][13] = 1.0; A[13][14] = 1.0; A[14][15] = 1.0; if (method == LAGRANGE_VEGAS) lmm_set_default_protocol_function(func_vegas_f, func_vegas_fp, func_vegas_fpi); else if (method == LAGRANGE_RENO) lmm_set_default_protocol_function(func_reno_f, func_reno_fp, func_reno_fpi); Sys = lmm_system_new(1); tmp_name = xbt_new0(char *, 31); /* * Creates the constraints */ tmp_cnst = xbt_new0(lmm_constraint_t, 15); for (i = 0; i < 15; i++) { tmp_name[i] = bprintf("C_%03d", i); tmp_cnst[i] = lmm_constraint_new(Sys, (void *) tmp_name[i], B[i]); } /* * Creates the variables */ tmp_var = xbt_new0(lmm_variable_t, 16); for (j = 0; j < 16; j++) { tmp_name[i + j] = bprintf("X_%03d", j); tmp_var[j] = lmm_variable_new(Sys, (void *) tmp_name[i + j], 1.0, -1.0, 15); lmm_update_variable_weight(Sys, tmp_var[j], 1.0); } /* * Link constraints and variables */ for (i = 0; i < 15; i++) { for (j = 0; j < 16; j++) { if (A[i][j]) { lmm_expand(Sys, tmp_cnst[i], tmp_var[j], 1.0); } } } if (method == MAXMIN) { lmm_solve(Sys); } else if (method == LAGRANGE_VEGAS) { lagrange_solve(Sys); } else if (method == LAGRANGE_RENO) { lagrange_solve(Sys); } else { xbt_die("Invalid method"); } for (j = 0; j < 16; j++) { PRINT_VAR(tmp_var[j]); } for (j = 0; j < 16; j++) lmm_variable_free(Sys, tmp_var[j]); xbt_free(tmp_var); xbt_free(tmp_cnst); for (i = 0; i < 31; i++) xbt_free(tmp_name[i]); xbt_free(tmp_name); lmm_system_free(Sys); for (i = 0; i < links + 5; i++) xbt_free(A[i]); xbt_free(A); } #ifdef __BORLANDC__ #pragma argsused #endif int main(int argc, char **argv) { xbt_init(&argc, argv); XBT_INFO("***** Test 1 (Max-Min)"); test1(MAXMIN); XBT_INFO("***** Test 1 (Lagrange - Vegas)"); test1(LAGRANGE_VEGAS); XBT_INFO("***** Test 1 (Lagrange - Reno)"); test1(LAGRANGE_RENO); XBT_INFO("***** Test 2 (Max-Min)"); test2(MAXMIN); XBT_INFO("***** Test 2 (Lagrange - Vegas)"); test2(LAGRANGE_VEGAS); XBT_INFO("***** Test 2 (Lagrange - Reno)"); test2(LAGRANGE_RENO); XBT_INFO("***** Test 3 (Max-Min)"); test3(MAXMIN); XBT_INFO("***** Test 3 (Lagrange - Vegas)"); test3(LAGRANGE_VEGAS); XBT_INFO("***** Test 3 (Lagrange - Reno)"); test3(LAGRANGE_RENO); return 0; } SimGrid-3.11/teshsuite/surf/lmm_usage/CMakeLists.txt000644 001750 001750 00000001241 12342443654 021536 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(lmm_usage ${CMAKE_HOME_DIRECTORY}/teshsuite/surf/lmm_usage/lmm_usage.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(lmm_usage simgrid m ) else() target_link_libraries(lmm_usage simgrid ) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/lmm_usage.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(testsuite_src ${testsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/lmm_usage.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/surf/maxmin_bench/000755 001750 001750 00000000000 12342443665 017461 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/surf/maxmin_bench/maxmin_bench.c000644 001750 001750 00000004443 12342443665 022262 0ustar00cici000000 000000 /* A crash few tests for the maxmin library */ /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifdef __BORLANDC__ #pragma hdrstop #endif #include "surf/maxmin.h" #include "xbt/module.h" #include "xbt/xbt_os_time.h" #include "xbt/sysdep.h" /* time manipulation for benchmarking */ #include #include double date; double float_random(double max); double float_random(double max) { return ((max * rand()) / (RAND_MAX + 1.0)); } int int_random(int max); int int_random(int max) { return (int) (((max * 1.0) * rand()) / (RAND_MAX + 1.0)); } void test(int nb_cnst, int nb_var, int nb_elem); void test(int nb_cnst, int nb_var, int nb_elem) { lmm_system_t Sys = NULL; lmm_constraint_t *cnst = xbt_new0(lmm_constraint_t, nb_cnst); lmm_variable_t *var = xbt_new0(lmm_variable_t, nb_var); int *used = xbt_new0(int, nb_cnst); int i, j, k; Sys = lmm_system_new(1); for (i = 0; i < nb_cnst; i++) { cnst[i] = lmm_constraint_new(Sys, NULL, float_random(10.0)); } for (i = 0; i < nb_var; i++) { var[i] = lmm_variable_new(Sys, NULL, 1.0, -1.0, nb_elem); for (j = 0; j < nb_cnst; j++) used[j] = 0; for (j = 0; j < nb_elem; j++) { k = int_random(nb_cnst); if (used[k]) { j--; continue; } lmm_expand(Sys, cnst[k], var[i], float_random(1.0)); used[k] = 1; } } printf("Starting to solve\n"); date = xbt_os_time() * 1000000; lmm_solve(Sys); date = xbt_os_time() * 1000000 - date; for (i = 0; i < nb_var; i++) lmm_variable_free(Sys, var[i]); lmm_system_free(Sys); free(cnst); free(var); free(used); } #ifdef __BORLANDC__ #pragma argsused #endif int main(int argc, char **argv) { int nb_cnst = 2000; int nb_var = 2000; int nb_elem = 80; xbt_init(&argc, argv); date = xbt_os_time() * 1000000; test(nb_cnst, nb_var, nb_elem); printf("One shot execution time for a total of %d constraints, " "%d variables with %d active constraint each : %g microsecondes \n", nb_cnst, nb_var, nb_elem, date); return 0; } SimGrid-3.11/teshsuite/surf/maxmin_bench/maxmin_bench.tesh000644 001750 001750 00000000332 12342443665 022774 0ustar00cici000000 000000 #! ./tesh ! output display $ $SG_TEST_EXENV ${bindir:=.}/maxmin_bench > Starting to solve > One shot execution time for a total of 2000 constraints, 2000 variables with 80 active constraint each : 66293 microsecondes SimGrid-3.11/teshsuite/surf/maxmin_bench/CMakeLists.txt000644 001750 001750 00000001404 12342443654 022216 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(maxmin_bench ${CMAKE_HOME_DIRECTORY}/teshsuite/surf/maxmin_bench/maxmin_bench.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(maxmin_bench simgrid m ) else() target_link_libraries(maxmin_bench simgrid ) set_target_properties(maxmin_bench PROPERTIES COMPILE_FLAGS "-DDLL_STATIC") endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/maxmin_bench.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(testsuite_src ${testsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/maxmin_bench.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/surf/trace_A.txt000644 001750 001750 00000000052 12342443666 017126 0ustar00cici000000 000000 PERIODICITY 1.0 0.0 1.0 11.0 0.5 20.0 0.9 SimGrid-3.11/teshsuite/surf/platform.xml000644 001750 001750 00000000716 12342443670 017377 0ustar00cici000000 000000 SimGrid-3.11/teshsuite/surf/trace_usage/000755 001750 001750 00000000000 12342443666 017314 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/surf/trace_usage/trace_usage.c000644 001750 001750 00000003301 12342443666 021737 0ustar00cici000000 000000 /* A few tests for the trace library */ /* Copyright (c) 2004-2006, 2009-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifdef __BORLANDC__ #pragma hdrstop #endif #include "surf/trace_mgr.h" #include "surf/surf.h" #include "xbt/log.h" #include #include #include XBT_LOG_NEW_DEFAULT_CATEGORY(surf_test, "Messages specific for surf example"); void test(void); void test(void) { tmgr_history_t history = tmgr_history_new(); tmgr_trace_t trace_A = tmgr_trace_new_from_file("trace_A.txt"); tmgr_trace_t trace_B = tmgr_trace_new_from_file("trace_B.txt"); double next_event_date = -1.0; double value = -1.0; char *resource = NULL; char *host_A = strdup("Host A"); char *host_B = strdup("Host B"); tmgr_history_add_trace(history, trace_A, 1.0, 2, host_A); tmgr_history_add_trace(history, trace_B, 0.0, 0, host_B); while ((next_event_date = tmgr_history_next_date(history)) != -1.0) { XBT_DEBUG("%g" " : \n", next_event_date); while (tmgr_history_get_next_event_leq(history, next_event_date, &value, (void **) &resource)) { XBT_DEBUG("\t %s : " "%g" "\n", resource, value); } if (next_event_date > 1000) break; } tmgr_history_free(history); free(host_B); free(host_A); } #ifdef __BORLANDC__ #pragma argsused #endif int main(int argc, char **argv) { surf_init(&argc, argv); test(); surf_exit(); return 0; } SimGrid-3.11/teshsuite/surf/trace_usage/trace_usage.tesh000644 001750 001750 00000000065 12342443665 022463 0ustar00cici000000 000000 #! ./tesh $ $SG_TEST_EXENV ${bindir:=.}/trace_usage SimGrid-3.11/teshsuite/surf/trace_usage/CMakeLists.txt000644 001750 001750 00000001257 12342443654 022056 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(trace_usage ${CMAKE_HOME_DIRECTORY}/teshsuite/surf/trace_usage/trace_usage.c) ### Add definitions for compile if(NOT WIN32) target_link_libraries(trace_usage simgrid m ) else() target_link_libraries(trace_usage simgrid ) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/trace_usage.tesh PARENT_SCOPE ) set(xml_files ${xml_files} PARENT_SCOPE ) set(testsuite_src ${testsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/trace_usage.c PARENT_SCOPE ) set(bin_files ${bin_files} PARENT_SCOPE ) set(txt_files ${txt_files} PARENT_SCOPE ) SimGrid-3.11/teshsuite/surf/trace_A_failure.txt000644 001750 001750 00000000042 12342443666 020634 0ustar00cici000000 000000 PERIODICITY 10.0 1.0 -1.0 2.0 1.0 SimGrid-3.11/teshsuite/surf/trace_B.txt000644 001750 001750 00000000053 12342443666 017130 0ustar00cici000000 000000 PERIODICITY 7.00 0.0 1.0 11.0 1.0 30.0 1.0 SimGrid-3.11/teshsuite/surf/CMakeLists.txt000644 001750 001750 00000000561 12342443654 017571 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") set(xml_files ${xml_files} ${CMAKE_CURRENT_SOURCE_DIR}/platform.xml PARENT_SCOPE ) set(txt_files ${txt_files} ${CMAKE_CURRENT_SOURCE_DIR}/trace_A_failure.txt ${CMAKE_CURRENT_SOURCE_DIR}/trace_A.txt ${CMAKE_CURRENT_SOURCE_DIR}/trace_B.txt PARENT_SCOPE ) SimGrid-3.11/teshsuite/mc/000755 001750 001750 00000000000 12342443654 014447 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/mc/dwarf_expression/000755 001750 001750 00000000000 12342443665 020033 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/mc/dwarf_expression/dwarf_expression.tesh000644 001750 001750 00000000074 12342443664 024302 0ustar00cici000000 000000 #! ./tesh $ $SG_TEST_EXENV ${bindir:=.}/dwarf-expression > SimGrid-3.11/teshsuite/mc/dwarf_expression/dwarf_expression.c000644 001750 001750 00000010057 12342443665 023564 0ustar00cici000000 000000 /* Copyright (c) 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include "../src/mc/mc_private.h" static uintptr_t eval_binary_operation(mc_expression_state_t state, int op, uintptr_t a, uintptr_t b) { state->stack_size = 0; Dwarf_Op ops[15]; ops[0].atom = DW_OP_const8u; ops[0].number = a; ops[1].atom = DW_OP_const8u; ops[1].number = b; ops[2].atom = op; assert(mc_dwarf_execute_expression(3, ops, state) == MC_EXPRESSION_OK); assert(state->stack_size==1); return state->stack[state->stack_size - 1]; } static void basic_test(mc_expression_state_t state) { Dwarf_Op ops[60]; uintptr_t a = rand(); uintptr_t b = rand(); ops[0].atom = DW_OP_drop; assert(mc_dwarf_execute_expression(1, ops, state) == MC_EXPRESSION_E_STACK_UNDERFLOW); ops[0].atom = DW_OP_lit21; assert(mc_dwarf_execute_expression(1, ops, state) == MC_EXPRESSION_OK); assert(state->stack_size==1); assert(state->stack[state->stack_size-1]==21); ops[0].atom = DW_OP_const8u; ops[0].number = a; assert(mc_dwarf_execute_expression(1, ops, state) == MC_EXPRESSION_OK); assert(state->stack_size==2); assert(state->stack[state->stack_size-1] == a); ops[0].atom = DW_OP_drop; ops[1].atom = DW_OP_drop; assert(mc_dwarf_execute_expression(2, ops, state) == MC_EXPRESSION_OK); assert(state->stack_size==0); ops[0].atom = DW_OP_lit21; ops[1].atom = DW_OP_plus_uconst; ops[1].number = a; assert(mc_dwarf_execute_expression(2, ops, state) == MC_EXPRESSION_OK); assert(state->stack_size==1); assert(state->stack[state->stack_size-1]== a + 21); state->stack_size = 0; ops[0].atom = DW_OP_const8u; ops[0].number = a; ops[1].atom = DW_OP_dup; ops[2].atom = DW_OP_plus; assert(mc_dwarf_execute_expression(3, ops, state) == MC_EXPRESSION_OK); assert(state->stack_size==1); assert(state->stack[state->stack_size-1]== a + a); state->stack_size = 0; ops[0].atom = DW_OP_const8u; ops[0].number = a; ops[1].atom = DW_OP_const8u; ops[1].number = b; ops[2].atom = DW_OP_over; assert(mc_dwarf_execute_expression(3, ops, state) == MC_EXPRESSION_OK); assert(state->stack_size==3); assert(state->stack[state->stack_size-1]== a); assert(state->stack[state->stack_size-2]== b); assert(state->stack[state->stack_size-3]== a); state->stack_size = 0; ops[0].atom = DW_OP_const8u; ops[0].number = a; ops[1].atom = DW_OP_const8u; ops[1].number = b; ops[2].atom = DW_OP_swap; assert(mc_dwarf_execute_expression(3, ops, state) == MC_EXPRESSION_OK); assert(state->stack_size=2); assert(state->stack[state->stack_size-1]== a); assert(state->stack[state->stack_size-2]== b); } static void test_deref(mc_expression_state_t state) { uintptr_t foo = 42; Dwarf_Op ops[60]; ops[0].atom = DW_OP_const8u; ops[0].number = (uintptr_t) &foo; ops[1].atom = DW_OP_deref; state->stack_size = 0; assert(mc_dwarf_execute_expression(2, ops, state) == MC_EXPRESSION_OK); assert(state->stack_size==1); assert(state->stack[state->stack_size-1] == foo); } int main(int argc, char** argv) { s_mc_expression_state_t state; memset(&state, 0, sizeof(s_mc_expression_state_t)); basic_test(&state); for(int i=0; i!=100; ++i) { uintptr_t a = rand(); uintptr_t b = rand(); assert(eval_binary_operation(&state, DW_OP_plus, a, b) == (a + b)); } for(int i=0; i!=100; ++i) { uintptr_t a = rand(); uintptr_t b = rand(); assert(eval_binary_operation(&state, DW_OP_or, a, b) == (a | b)); } for(int i=0; i!=100; ++i) { uintptr_t a = rand(); uintptr_t b = rand(); assert(eval_binary_operation(&state, DW_OP_and, a, b) == (a & b)); } for(int i=0; i!=100; ++i) { uintptr_t a = rand(); uintptr_t b = rand(); assert(eval_binary_operation(&state, DW_OP_xor, a, b) == (a ^ b)); } test_deref(&state); return 0; } SimGrid-3.11/teshsuite/mc/dwarf_expression/CMakeLists.txt000644 001750 001750 00000000656 12342443654 022600 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(HAVE_MC) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(dwarf-expression dwarf_expression.c) target_link_libraries(dwarf-expression simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/dwarf_expression.tesh PARENT_SCOPE ) set(testsuite_src ${testsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/dwarf_expression.c PARENT_SCOPE ) SimGrid-3.11/teshsuite/mc/dwarf/000755 001750 001750 00000000000 12342443665 015554 5ustar00cici000000 000000 SimGrid-3.11/teshsuite/mc/dwarf/dwarf.c000644 001750 001750 00000012030 12342443665 017017 0ustar00cici000000 000000 /* Copyright (c) 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include #include "../../src/include/mc/datatypes.h" #include "../../src/mc/mc_private.h" int test_some_array[4][5][6]; struct some_struct { int first; int second[4][5]; } test_some_struct; static dw_type_t find_type_by_name(mc_object_info_t info, const char* name) { xbt_dict_cursor_t cursor = NULL; char *key; dw_type_t type; xbt_dict_foreach(info->types, cursor, key, type) { if(!strcmp(name, type->name)) return type; } return NULL; } static dw_variable_t find_global_variable_by_name(mc_object_info_t info, const char* name) { unsigned int cursor = 0; dw_variable_t variable; xbt_dynar_foreach(info->global_variables, cursor, variable){ if(!strcmp(name, variable->name)) return variable; } return NULL; } static dw_frame_t find_function_by_name(mc_object_info_t info, const char* name) { xbt_dict_cursor_t cursor = 0; dw_frame_t subprogram; char* key; xbt_dict_foreach(info->subprograms, cursor, key, subprogram){ if(!strcmp(name, subprogram->name)) return subprogram; } return NULL; } static dw_variable_t find_local_variable(dw_frame_t frame, const char* argument_name) { unsigned int cursor = 0; dw_variable_t variable; xbt_dynar_foreach(frame->variables, cursor, variable){ if(!strcmp(argument_name, variable->name)) return variable; } dw_frame_t scope = NULL; xbt_dynar_foreach(frame->scopes, cursor, scope) { variable = find_local_variable(scope, argument_name); if(variable) return variable; } return NULL; } static void test_local_variable(mc_object_info_t info, const char* function, const char* variable, void* address, unw_cursor_t* cursor) { dw_frame_t subprogram = find_function_by_name(info, function); assert(subprogram); // TODO, Lookup frame by IP and test against name instead dw_variable_t var = find_local_variable(subprogram, variable); assert(var); void* frame_base = mc_find_frame_base(subprogram, info, cursor); xbt_assert((void*)mc_dwarf_resolve_locations(&var->locations, info, cursor, frame_base, NULL) == address, "Bad resolution of local variable %s of %s", variable, function); } static dw_variable_t test_global_variable(mc_object_info_t info, const char* name, void* address, long byte_size) { dw_variable_t variable = find_global_variable_by_name(info, name); xbt_assert(variable, "Global variable %s was not found", name); xbt_assert(!strcmp(variable->name, name), "Name mismatch for %s", name); xbt_assert(variable->global, "Variable %s is not global", name); xbt_assert(variable->address == address, "Address mismatch for %s : %p expected but %p found", name, address, variable->address); dw_type_t type = xbt_dict_get_or_null(mc_binary_info->types, variable->type_origin); xbt_assert(type!=NULL, "Missing type for %s", name); xbt_assert(type->byte_size = byte_size, "Byte size mismatch for %s", name); return variable; } static dw_type_t find_member(mc_object_info_t info, const char* name, dw_type_t type) { unsigned int cursor = 0; dw_type_t member; xbt_dynar_foreach(type->members, cursor, member){ if(!strcmp(name,member->name)) return member; } return NULL; } int some_local_variable = 0; typedef struct foo {int i;} s_foo; static void test_type_by_name(s_foo my_foo) { assert(xbt_dict_get_or_null(mc_binary_info->full_types_by_name, "struct foo")); } int main(int argc, char** argv) { // xbt_init(&argc, argv); SIMIX_global_init(&argc, argv); MC_memory_init(); MC_init(); dw_variable_t var; dw_type_t type; test_global_variable(mc_binary_info, "some_local_variable", &some_local_variable, sizeof(int)); var = test_global_variable(mc_binary_info, "test_some_array", &test_some_array, sizeof(test_some_array)); type = xbt_dict_get_or_null(mc_binary_info->types, var->type_origin); xbt_assert(type->element_count == 6*5*4, "element_count mismatch in test_some_array : %i / %i", type->element_count, 6*5*4); var = test_global_variable(mc_binary_info, "test_some_struct", &test_some_struct, sizeof(test_some_struct)); type = xbt_dict_get_or_null(mc_binary_info->types, var->type_origin); assert(find_member(mc_binary_info, "first", type)->offset == 0); assert(find_member(mc_binary_info, "second", type)->offset == ((const char*)&test_some_struct.second) - (const char*)&test_some_struct); unw_context_t context; unw_cursor_t cursor; unw_getcontext(&context); unw_init_local(&cursor, &context); test_local_variable(mc_binary_info, "main", "argc", &argc, &cursor); { int lexical_block_variable = 50; test_local_variable(mc_binary_info, "main", "lexical_block_variable", &lexical_block_variable, &cursor); } s_foo my_foo; test_type_by_name(my_foo); _exit(0); } SimGrid-3.11/teshsuite/mc/dwarf/dwarf.tesh000644 001750 001750 00000000242 12342443664 017541 0ustar00cici000000 000000 #! ./tesh $ $SG_TEST_EXENV ${bindir:=.}/dwarf > [0.000000] [mc_global/INFO] Get debug information ... > [0.000000] [mc_global/INFO] Get debug information done ! SimGrid-3.11/teshsuite/mc/dwarf/CMakeLists.txt000644 001750 001750 00000000567 12342443654 020322 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) if(HAVE_MC) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}") add_executable(dwarf dwarf.c) target_link_libraries(dwarf simgrid) endif() set(tesh_files ${tesh_files} ${CMAKE_CURRENT_SOURCE_DIR}/dwarf.tesh PARENT_SCOPE ) set(testsuite_src ${testsuite_src} ${CMAKE_CURRENT_SOURCE_DIR}/dwarf.c PARENT_SCOPE ) SimGrid-3.11/CITATION.bib000644 001750 001750 00000001127 12342443656 013726 0ustar00cici000000 000000 @InProceedings{Casanova:2008:SGF:1397760.1398183, author = {Casanova, Henri and Legrand, Arnaud and Quinson, Martin}, title = {SimGrid: a Generic Framework for Large-Scale Distributed Experiments}, booktitle = {Proceedings of the Tenth International Conference on Computer Modeling and Simulation}, series = {UKSIM '08}, year = {2008}, isbn = {978-0-7695-3114-4}, pages = {126--131}, numpages = {6}, url = {http://dx.doi.org/10.1109/UKSIM.2008.28}, doi = {10.1109/UKSIM.2008.28}, acmid = {1398183}, publisher = {IEEE Computer Society}, address = {Washington, DC, USA}, } SimGrid-3.11/TODO000644 001750 001750 00000004121 12342443666 012524 0ustar00cici000000 000000 ************************************************ *** This file is a TODO. It is thus kinda *** *** outdated. You know the story, right? *** ************************************************ ### ### Urgent stuff: ### * Have a proper todo file ### ### Ongoing stuff ### * Switch to tesh.pl, and kill the now unused parts of xbt that seem fragile * Clean up CMake files (may need a full rewrite). Non exhaustive list of subgoals: - Use genuine cmake mechanisms and variables when available, instead of reinventing the wheel. - Correctly determine system and architecture (e.g. x32). - Correctly determine compiler type and version (e.g. clang). - Correctly set compiler flags according to compiler type and version. - Correctly set compiler flags for C++, Java, and Fortran compilers too. - Use git to generate the dist archive. Either use git-archive to generate the tarball, or keep using cmake -E tar, but use git-ls-files to get the list of files to pack. * Document host module * /* FIXME: better place? */ int vasprintf (char **ptr, const char *fmt, va_list ap); char *bprintf(const char*fmt, ...) _XBT_GNUC_PRINTF(1,2); ### ### Planned ### * * XBT ***** [errors/exception] * Better split casual errors from programming errors. The first ones should be reported to the user, the second should kill the program (or, yet better, only the msg handler) * Allows the use of an error handler depending on the current module (ie, the same philosophy as log4c using GSL's error functions) [logs] * Hijack message from a given category to another for a while (to mask initializations, and more) * Allow each actor to have its own setting * more logging appenders (take those from Ralf in l2) [modules] * Add configuration and dependencies to our module definition [other modules] * we may need a round-robin database module, and a statistical one * Some of the datacontainer modules seem to overlap. Kill some of them? - replace fifo with dynars - replace set with SWAG SimGrid-3.11/README.java000644 001750 001750 00000000637 12342443666 013644 0ustar00cici000000 000000 On Debian-like systems (which includes ubuntu), you need the following packages: sun-java6-jdk libgcj10-dev. If you cannot find the libgcj10-dev, try another version, like libgcj9-dev (on Ubuntu before 9.10) or libgcj11-dev (not released yet, but certainly one day). Please note that you need to activate the contrib and non-free repositories in Debian, and the universe ones in Ubuntu. Java comes at this price... SimGrid-3.11/COPYING000644 001750 001750 00000040437 12342443666 013101 0ustar00cici000000 000000 Most of the SimGrid software was written internally by the team. This software is distributed under the GNU lesser general public license version 2.1, which you can find in the archive under the name LICENSE-LGPL-2.1. For any copyright year range specified as YYYY-ZZZZ in this package note that the range specifies every single year in that closed interval. Some perticular files distributed with the project have other licenses. More specifically, these files are listed below, along with their license. The SimGrid logo is distributed under the CC-BY-SA license. ========================================================================= The file src/xbt/snprintf.c contains this license text: /* * snprintf.c - a portable implementation of snprintf * * AUTHOR * Mark Martinec , April 1999. * * Copyright 1999, Mark Martinec. All rights reserved. * * TERMS AND CONDITIONS * This program is free software; you can redistribute it and/or modify * it under the terms of the "Frontier Artistic License" which comes * with this Kit. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the Frontier Artistic License for more details. * * You should have received a copy of the Frontier Artistic License * with this Kit in the file named LICENSE.txt . * If not, I'll be glad to provide one. * */ ========================================================================= The exception handling mecanism (mainly living in src/xbt/ex.c and include/xbt/ex.h) was adapted from code from Ralf S. Engelschall and others in the OSSP project. The OSSP version has the following license: ** OSSP ex - Exception Handling ** Copyright (c) 2002-2007 Ralf S. Engelschall ** Copyright (c) 2002-2007 The OSSP Project ** ** This file is part of OSSP ex, an exception handling library ** which can be found at http://www.ossp.org/pkg/lib/ex/. ** ** Permission to use, copy, modify, and distribute this software for ** any purpose with or without fee is hereby granted, provided that ** the above copyright notice and this permission notice appear in all ** copies. ** ** THIS SOFTWARE IS PROVIDED `AS IS'' AND ANY EXPRESSED OR IMPLIED ** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF ** MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ** IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR ** CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF ** USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT ** OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ** SUCH DAMAGE. ========================================================================= The sha implementation (src/xbt/xbt_sha.c:) was borowed and adapted from the iksemel one (http://code.google.com/p/iksemel/). Both the original and the current version of this code is distributed under the LGPL v2.1 license. ========================================================================= The xbt/mmalloc module was adapted from the mmalloc module of gdb. Both the simgrid version and the original version is distributed under the LGPL v2.1 This affects the files in directory src/xbt/mmalloc and include/xbt/mmalloc.h ========================================================================= In order to use ucontext with windows platform we had those files : src/xbt/win32_ucontext.c src/include/xbt/win32_ucontext.h Their copyright is the following: /* * win32-ucontext: Unix ucontext_t operations on Windows platforms * Copyright(C) 2007 Panagiotis E. Hadjidoukas * * Contact Email: phadjido@cs.uoi.gr, xdoukas@ceid.upatras.gr * * win32-ucontext is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * win32-ucontext is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with SimGrid in the file LICENSE-LGPL-2.1; * if not, write to the Free Software Foundation, Inc., * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. */ ========================================================================= Some examples for SMPI were borowed from an IBM test suite. Their copyright is the following: /** * MESSAGE PASSING INTERFACE TEST CASE SUITE * * Copyright IBM Corp. 1995 * * IBM Corp. hereby grants a non-exclusive license to use, copy, modify, and *distribute this software for any purpose and without fee provided that the *above copyright notice and the following paragraphs appear in all copies. * IBM Corp. makes no representation that the test cases comprising this * suite are correct or are an accurate representation of any standard. * In no event shall IBM be liable to any party for direct, indirect, special * incidental, or consequential damage arising out of the use of this software * even if IBM Corp. has been advised of the possibility of such damage. * IBM CORP. SPECIFICALLY DISCLAIMS ANY WARRANTIES INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS AND IBM * CORP. HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, * ENHANCEMENTS, OR MODIFICATIONS. * *************************************************************************** **/ List of files: examples/smpi/scatter.c examples/smpi/reduce.c examples/smpi/allreduce.c examples/smpi/alltoall2.c ========================================================================= The SMPI testsuite was borrowed from the MPICH3 test files. It can be found inside ./teshsuite/smpi/mpich3-test. Some of the collective algorithms available in src/smpi/colls/ were also copied from MPICH /* * (C) 2001 by Argonne National Laboratory. * See COPYRIGHT in top-level directory. */ <------------- COPYRIGHT file in the top-level -----------------------> COPYRIGHT The following is a notice of limited availability of the code, and disclaimer which must be included in the prologue of the code and in all source listings of the code. Copyright Notice + 2002 University of Chicago Permission is hereby granted to use, reproduce, prepare derivative works, and to redistribute to others. This software was authored by: Mathematics and Computer Science Division Argonne National Laboratory, Argonne IL 60439 (and) Department of Computer Science University of Illinois at Urbana-Champaign GOVERNMENT LICENSE Portions of this material resulted from work developed under a U.S. Government Contract and are subject to the following license: the Government is granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable worldwide license in this computer software to reproduce, prepare derivative works, and perform publicly and display publicly. DISCLAIMER This computer code material was prepared, in part, as an account of work sponsored by an agency of the United States Government. Neither the United States, nor the University of Chicago, 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. <-------------------- end of MPICH2 COPYRIGHT file --------------------> ========================================================================= The directory examples/smpi/NAS contains a tweaked version of the NAS Parallel Benchmark Team. The original software were retrieved from here: http://www.nas.nasa.gov/Software/NPB According to [1], this code is probably distributed under the NASA Open Source Agreement (NOSA) version 1.3. Its text can be found at [2]. [1] http://www.nas.nasa.gov/Resources/Software/Open-Source/opensource.html [2] http://www.opensource.org/licenses/nasa1.3.php The changes over the original version are minor, and can be distributed under the LGPL license (v2.1) or NOSA (v1.3 or higher) licences, at your option. ========================================================================== Some of the collective algorithms inside src/smpi/colls folder are taken from the STAR-MPI suite. The original software was retrieved from here: http://star-mpi.sourceforge.net/ Copyright (c) 2006, Ahmad Faraj & Xin Yuan, All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the Florida State University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************** * Any results obtained from executing this software require the * * acknowledgment and citation of the software and its owners. * * The full citation is given below: * * * * A. Faraj, X. Yuan, and D. Lowenthal. "STAR-MPI: Self Tuned Adaptive * * Routines for MPI Collective Operations." The 20th ACM International * * Conference on Supercomputing (ICS), Queensland, Australia * * June 28-July 1, 2006. * *************************************************************************** ========================================================================== Some of the collective algorithms inside src/smpi/colls folder are taken from the OpenMPI. The original software was retrieved from here: http://www.open-mpi.org/ Most files in this release are marked with the copyrights of the organizations who have edited them. The copyrights below are in no particular order and generally reflect members of the Open MPI core team who have contributed code to this release. The copyrights for code used under license from other parties are included in the corresponding files. Copyright (c) 2004-2010 The Trustees of Indiana University and Indiana University Research and Technology Corporation. All rights reserved. Copyright (c) 2004-2010 The University of Tennessee and The University of Tennessee Research Foundation. All rights reserved. Copyright (c) 2004-2010 High Performance Computing Center Stuttgart, University of Stuttgart. All rights reserved. Copyright (c) 2004-2008 The Regents of the University of California. All rights reserved. Copyright (c) 2006-2010 Los Alamos National Security, LLC. All rights reserved. Copyright (c) 2006-2010 Cisco Systems, Inc. All rights reserved. Copyright (c) 2006-2010 Voltaire, Inc. All rights reserved. Copyright (c) 2006-2011 Sandia National Laboratories. All rights reserved. Copyright (c) 2006-2010 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms. Copyright (c) 2006-2010 The University of Houston. All rights reserved. Copyright (c) 2006-2009 Myricom, Inc. All rights reserved. Copyright (c) 2007-2008 UT-Battelle, LLC. All rights reserved. Copyright (c) 2007-2010 IBM Corporation. All rights reserved. Copyright (c) 1998-2005 Forschungszentrum Juelich, Juelich Supercomputing Centre, Federal Republic of Germany Copyright (c) 2005-2008 ZIH, TU Dresden, Federal Republic of Germany Copyright (c) 2007 Evergrid, Inc. All rights reserved. Copyright (c) 2008 Chelsio, Inc. All rights reserved. Copyright (c) 2008-2009 Institut National de Recherche en Informatique. All rights reserved. Copyright (c) 2007 Lawrence Livermore National Security, LLC. All rights reserved. Copyright (c) 2007-2009 Mellanox Technologies. All rights reserved. Copyright (c) 2006-2010 QLogic Corporation. All rights reserved. Copyright (c) 2008-2010 Oak Ridge National Labs. All rights reserved. Copyright (c) 2006-2010 Oracle and/or its affiliates. All rights reserved. Copyright (c) 2009 Bull SAS. All rights reserved. Copyright (c) 2010 ARM ltd. All rights reserved. Copyright (c) 2010-2011 Alex Brick . All rights reserved. Copyright (c) 2012 The University of Wisconsin-La Crosse. All rights reserved. $COPYRIGHT$ Additional copyrights may follow $HEADER$ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer listed in this license in the documentation and/or other materials provided with the distribution. - Neither the name of the copyright holders nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. The copyright holders provide no reassurances that the source code provided does not infringe any patent, copyright, or any other intellectual property rights of third parties. The copyright holders disclaim any liability to any recipient for claims brought against recipient by any third party for infringement of that parties intellectual property rights. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ========================================================================== SimGrid-3.11/ChangeLog.SimGrid-java000644 001750 001750 00000005571 12342443666 016074 0ustar00cici000000 000000 ChangeLog for SimGrid-java, before its integration into the main source tree. SimGrid-java (3.9) stable; urgency=low -- 2013-01-30 Da SimGrid team SimGrid-java (3.8.1) stable; urgency=low * New module: org.simgrid.trace.Trace (SimGrid trace bindings) Warning: all methods are visible, but only some of them are implemented so far. Check the source (src/jtrace.c) for further information. * New module: org.simgrid.msg.File (SimGrid File management functions) * New Module: org.simgrid.msg.VM (SimGrid interface to mimick IAAS clouds) * Change the meaning of Process.restart: now restart the process from the begining, like MSG_process_restart in C. * Add Process.setAutoRestart: handling of process restart when failed host comes back. * Add Process.getProperty, Host.getProperty, Host.getProperty: allows you to retrieve the properties of the processes/hosts * Deprecate Msg.clean(): you can just forget about it now. * New function Process.getCount(), that only works when compiling with the not yet released version 3.9 of the C library. * New context factory based on Coroutines. It mandates a modified JVM but then, the simulations run about five times faster, and there is no limit to the amount of processes (beside of the available memory). -- 2012-12-04 Da SimGrid team SimGrid-java (3.7.1) stable; urgency=low The "Java aint got to be bloated and slow" release Major cleanups: * Various internal cleanups and performance improvement Simulations are expected to run up to twice faster or so * Make Process.kill(process) an instance method, not a static one * User processes are not java.lang.Thread subclasses. This breaks the compatibility (sorry), but previous API was brain-dead, making it impossible to have non-trivial initializations in the process constructor. * Require a full constructor per Process sub-class. Kinda breaks the compatibility (sorry), but this allows a much more efficient way to launch the processes at simulation startup. * Do not embeed our version of semaphores, java 1.5 can be considered as sufficiently prevalent for us to not dupplicate its features. * Lot of bug fixes Extend the API: * Add examples for almost every part of the API We spotted and fixed a lot of bugs in the process * New module: asynchronous communication API * New function: Process.sleep() It takes milliseconds as argument, just as java.lang.Thread.sleep() * New module: org.simgrid.msg.Mutex (SimGrid mutexes) * New module: org.simgrid.msg.RngStream (RngStreams random generators) -- 2012-06-12 Da SimGrid team SimGrid-java (1.0 (3.6) unstable; urgency=low * Initial release. * Split of every thing from simgrid v3.5 into a separate package. -- 2011-10-05 Da SimGrid team SimGrid-3.11/buildtools/000755 001750 001750 00000000000 12342443653 014212 5ustar00cici000000 000000 SimGrid-3.11/buildtools/Cmake/000755 001750 001750 00000000000 12342443653 015232 5ustar00cici000000 000000 SimGrid-3.11/buildtools/Cmake/CTestConfig.cmake000644 001750 001750 00000003203 12342443653 020402 0ustar00cici000000 000000 # Configure CTest. For details, see: # http://www.cmake.org/Wiki/CMake_Testing_With_CTest#Customizing_CTest if(APPLE) SET(BUILDNAME "APPLE" CACHE TYPE INTERNAL FORCE) else() SET(BUILDNAME "UNIX" CACHE TYPE INTERNAL FORCE) if(WIN32) SET(BUILDNAME "WINDOWS" CACHE TYPE INTERNAL FORCE) endif() endif() if(enable_memcheck) set(CTEST_TIMEOUT "300") #TIMEOUT FOR EACH TEST endif() if(enable_compile_warnings AND enable_compile_optimizations) SET(BUILDNAME "FULL_FLAGS" CACHE TYPE INTERNAL FORCE) endif() if(HAVE_GTNETS) SET(BUILDNAME "GTNETS" CACHE TYPE INTERNAL FORCE) endif() if(HAVE_MC) SET(BUILDNAME "MODEL-CHECKING" CACHE TYPE INTERNAL FORCE) endif() if(enable_memcheck) SET(BUILDNAME "MEMCHECK" CACHE TYPE INTERNAL FORCE) endif() set(osname ${CMAKE_SYSTEM_NAME}) set(cpu ${CMAKE_SYSTEM_PROCESSOR}) set(DISTRIB2 ${CMAKE_SYSTEM_VERSION}) SET(SITE "${osname}_${DISTRIB2}_${cpu}") SET(CTEST_SITE "${osname}_${DISTRIB2}_${cpu}") SET(CTEST_PROJECT_NAME "${PROJECT_NAME}") SET(CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE "3000000") SET(CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE "3000000") set(PIPOL_IMAGE $ENV{PIPOL_IMAGE}) if(NOT ${PIPOL_IMAGE} MATCHES "\n") set(SITE ${PIPOL_IMAGE}) endif() set(PATTERN_CTEST_IGNORED "") if(enable_coverage) set(PATTERN_CTEST_IGNORED "/tools/" "/buildtools/" "/include/" "/teshsuite/" "/src/bindings/" ) if(NOT release) set(PATTERN_CTEST_IGNORED ${PATTERN_CTEST_IGNORED} "/examples/" ) endif() endif() CONFIGURE_FILE(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/CTestCustom.cmake ${CMAKE_BINARY_DIR}/CTestCustom.cmake @ONLY) SimGrid-3.11/buildtools/Cmake/src/000755 001750 001750 00000000000 12342443653 016021 5ustar00cici000000 000000 SimGrid-3.11/buildtools/Cmake/src/simgrid.nsi.in000644 001750 001750 00000036131 12342443653 020603 0ustar00cici000000 000000 !include "MUI2.nsh" ;-------------------------------- ;Interface Configuration !define MUI_HEADERIMAGE !define MUI_HEADERIMAGE_BITMAP "@CMAKE_HOME_DIRECTORY@\doc\webcruft\simgrid_logo_win_2011.bmp" ; optional !define MUI_ABORTWARNING ;-------------------------------- ;Pages !insertmacro MUI_PAGE_LICENSE "@CMAKE_HOME_DIRECTORY@\LICENSE-LGPL-2.1" !insertmacro MUI_PAGE_COMPONENTS !insertmacro MUI_PAGE_DIRECTORY !insertmacro MUI_PAGE_INSTFILES !insertmacro MUI_PAGE_FINISH !insertmacro MUI_UNPAGE_CONFIRM !insertmacro MUI_UNPAGE_INSTFILES !insertmacro MUI_UNPAGE_FINISH ;-------------------------------- ;Languages !insertmacro MUI_LANGUAGE "English" !insertmacro MUI_LANGUAGE "French" ;-------------------------------- Name "Simgrid" outFile "SimGrid-@SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@_SGjava_@NSIS_WIN_VERSION@@BIN_EXE@" Icon "@CMAKE_HOME_DIRECTORY@\doc\webcruft\SGicon.ico" RequestExecutionLevel admin # set the default installation directory InstallDir c:\SimGrid@SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@ Section "Libraries and Headers" LibSection setOutPath $INSTDIR file @CMAKE_HOME_DIRECTORY@\AUTHORS file @CMAKE_HOME_DIRECTORY@\Changelog file @CMAKE_HOME_DIRECTORY@\COPYING file @CMAKE_HOME_DIRECTORY@\LICENSE-LGPL-2.1 file @CMAKE_HOME_DIRECTORY@\NEWS # install lib CreateDirectory $INSTDIR\lib setOutPath $INSTDIR\lib file lib\libsimgrid.dll file lib\libsimgrid.def #install headers CreateDirectory $INSTDIR\include setOutPath $INSTDIR\include file @CMAKE_HOME_DIRECTORY@\include\xbt.h file include\simgrid_config.h CreateDirectory $INSTDIR\include\xbt setOutPath $INSTDIR\include\xbt file @CMAKE_HOME_DIRECTORY@\include\xbt\misc.h file @CMAKE_HOME_DIRECTORY@\include\xbt\sysdep.h file @CMAKE_HOME_DIRECTORY@\include\xbt\virtu.h file @CMAKE_HOME_DIRECTORY@\include\xbt\str.h file @CMAKE_HOME_DIRECTORY@\include\xbt\strbuff.h file @CMAKE_HOME_DIRECTORY@\include\xbt\hash.h file @CMAKE_HOME_DIRECTORY@\include\xbt\function_types.h file @CMAKE_HOME_DIRECTORY@\include\xbt\asserts.h file @CMAKE_HOME_DIRECTORY@\include\xbt\ex.h file @CMAKE_HOME_DIRECTORY@\include\xbt\log.h file @CMAKE_HOME_DIRECTORY@\include\xbt\module.h file @CMAKE_HOME_DIRECTORY@\include\xbt\mallocator.h file @CMAKE_HOME_DIRECTORY@\include\xbt\dynar.h file @CMAKE_HOME_DIRECTORY@\include\xbt\dict.h file @CMAKE_HOME_DIRECTORY@\include\xbt\set.h file @CMAKE_HOME_DIRECTORY@\include\xbt\heap.h file @CMAKE_HOME_DIRECTORY@\include\xbt\graph.h file @CMAKE_HOME_DIRECTORY@\include\xbt\fifo.h file @CMAKE_HOME_DIRECTORY@\include\xbt\swag.h file @CMAKE_HOME_DIRECTORY@\include\xbt\lib.h file @CMAKE_HOME_DIRECTORY@\include\xbt\matrix.h file @CMAKE_HOME_DIRECTORY@\include\xbt\peer.h file @CMAKE_HOME_DIRECTORY@\include\xbt\config.h file @CMAKE_HOME_DIRECTORY@\include\xbt\cunit.h file @CMAKE_HOME_DIRECTORY@\include\xbt\graphxml_parse.h file @CMAKE_HOME_DIRECTORY@\include\xbt\graphxml.h file @CMAKE_HOME_DIRECTORY@\include\xbt\synchro_core.h file @CMAKE_HOME_DIRECTORY@\include\xbt\queue.h file @CMAKE_HOME_DIRECTORY@\include\xbt\setset.h file @CMAKE_HOME_DIRECTORY@\include\xbt\mmalloc.h file @CMAKE_HOME_DIRECTORY@\include\xbt\parmap.h file @CMAKE_HOME_DIRECTORY@\include\xbt\automaton.h file @CMAKE_HOME_DIRECTORY@\include\xbt\xbt_os_thread.h file @CMAKE_HOME_DIRECTORY@\include\xbt\RngStream.h CreateDirectory $INSTDIR\include\simgrid setOutPath $INSTDIR\include\simgrid file @CMAKE_HOME_DIRECTORY@\include\simgrid\platf.h file @CMAKE_HOME_DIRECTORY@\include\simgrid\modelchecker.h file @CMAKE_HOME_DIRECTORY@\include\simgrid\simix.h CreateDirectory $INSTDIR\include\msg setOutPath $INSTDIR\include\msg file @CMAKE_HOME_DIRECTORY@\include\msg\msg.h file @CMAKE_HOME_DIRECTORY@\include\msg\datatypes.h CreateDirectory $INSTDIR\include\simdag setOutPath $INSTDIR\include\simdag file @CMAKE_HOME_DIRECTORY@\include\simdag\simdag.h file @CMAKE_HOME_DIRECTORY@\include\simdag\datatypes.h CreateDirectory $INSTDIR\include\surf setOutPath $INSTDIR\include\surf file @CMAKE_HOME_DIRECTORY@\include\surf\surfxml_parse.h file @CMAKE_HOME_DIRECTORY@\include\surf\simgrid_dtd.h file @CMAKE_HOME_DIRECTORY@\include\surf\surf_routing.h CreateDirectory $INSTDIR\include\instr setOutPath $INSTDIR\include\instr file @CMAKE_HOME_DIRECTORY@\include\instr\instr.h SectionEnd Section "Binaries" BinSection # insatll bin CreateDirectory $INSTDIR\bin setOutPath $INSTDIR\bin file bin\colorize file bin\graphicator@BIN_EXE@ file bin\simgrid_update_xml SectionEnd Section "Documentation" DocSection # install doc CreateDirectory $INSTDIR\doc setOutPath $INSTDIR\doc file /nonfatal /r @CMAKE_HOME_DIRECTORY@\doc\html # create a shortcut in the start menu programs directory CreateDirectory "$SMPROGRAMS\SimGrid @SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@" createShortCut "$SMPROGRAMS\SimGrid @SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@\Documentation.lnk" "$INSTDIR\doc\html\index.html" createShortCut "$SMPROGRAMS\SimGrid @SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@\Website.lnk" "http://simgrid.gforge.inria.fr/" SectionEnd Section "Examples" ExamplesSection CreateDirectory $INSTDIR\examples setOutPath $INSTDIR\examples #install examples for platforms file /r @CMAKE_HOME_DIRECTORY@\examples\platforms # install example HelloWorld file /r @CMAKE_HOME_DIRECTORY@\doc\HelloWorld # install example MasterSlave CreateDirectory $INSTDIR\examples\MasterSlave setOutPath $INSTDIR\examples\MasterSlave file @CMAKE_HOME_DIRECTORY@\examples\msg\masterslave\masterslave_forwarder.c file @CMAKE_HOME_DIRECTORY@\examples\msg\masterslave\deployment_masterslave_forwarder.xml file @CMAKE_HOME_DIRECTORY@\examples\msg\msg_platform.xml file @CMAKE_HOME_DIRECTORY@\doc\HelloWorld\CMakeLists.txt # create shortcuts in the start menu programs directory CreateDirectory "$SMPROGRAMS\SimGrid @SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@\Examples\" createShortCut "$SMPROGRAMS\SimGrid @SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@\Examples\HelloWorld project.lnk" "$INSTDIR\examples\HelloWorld" createShortCut "$SMPROGRAMS\SimGrid @SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@\Examples\MasterSlave project.lnk" "$INSTDIR\examples\MasterSlave" SectionEnd Section "Java Bindings" JavaSection # install java library and examples CreateDirectory $INSTDIR\examples\simgrid-java setOutPath $INSTDIR\lib file /nonfatal "lib\simgrid-java.dll" file /nonfatal "lib\simgrid-java.def" file /nonfatal "simgrid.jar" setOutPath $INSTDIR\examples\simgrid-java file /nonfatal /r ".\examples\" # create shortcuts in the start menu programs directory createShortCut "$SMPROGRAMS\SimGrid @SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@\Examples\Java project.lnk" "$INSTDIR\examples\simgrid-java" # create a popup box, with an OK button" messageBox MB_OK "WARNING! Please add to your environment variable CLASSPATH value '$INSTDIR\lib\simgrid.jar;.' before executing Simgrid classes." SectionEnd Section "SMPI Library" SMPISection setOutPath $INSTDIR\bin file bin\smpicc file bin\smpif2c file bin\smpiff file bin\smpirun file bin\smpif90 setOutPath $INSTDIR\lib CreateDirectory $INSTDIR\include\smpi setOutPath $INSTDIR\include\smpi file @CMAKE_HOME_DIRECTORY@\include\smpi\smpi.h file @CMAKE_HOME_DIRECTORY@\include\smpi\mpi.h file @CMAKE_HOME_DIRECTORY@\include\smpi\smpi_cocci.h file @CMAKE_HOME_DIRECTORY@\include\smpi\smpi_main.h file include\smpi\mpif.h file include\smpi\smpif.h CreateDirectory $INSTDIR\examples\smpi file /r @CMAKE_HOME_DIRECTORY@\examples\smpi\tracing file /r @CMAKE_HOME_DIRECTORY@\examples\smpi\replay setOutPath $INSTDIR\examples\smpi file @CMAKE_HOME_DIRECTORY@\examples\smpi\bcbench.c file @CMAKE_HOME_DIRECTORY@\examples\smpi\mvmul.c file /r @CMAKE_HOME_DIRECTORY@\examples\smpi\mc file @CMAKE_HOME_DIRECTORY@\examples\smpi\hostfile file @CMAKE_HOME_DIRECTORY@\examples\msg\small_platform_with_routers.xml file @CMAKE_HOME_DIRECTORY@\examples\smpi\CMakeLists.txt SectionEnd # default section start section # define uninstaller name writeUninstaller $INSTDIR\uninstaller@BIN_EXE@ # create a shortcut in the start menu programs directory CreateDirectory "$SMPROGRAMS\SimGrid @SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@" createShortCut "$SMPROGRAMS\SimGrid @SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@\Uninstall simgrid.lnk" "$INSTDIR\uninstaller@BIN_EXE@" # Include for some of the windows message defines !include "winmessages.nsh" # HKLM (all users) vs HKCU (current user) defines !define env_hklm 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"' !define env_hkcu 'HKCU "Environment"' # Set Variables WriteRegExpandStr ${env_hkcu} SIMGRID_ROOT $INSTDIR WriteRegExpandStr ${env_hkcu} SIMGRID_VERSION @SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@ WriteRegStr HKCU "SOFTWARE\SimGrid" "Version" "@SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@" WriteRegStr HKCU "SOFTWARE\SimGrid" "InstallPath" "$INSTDIR" # create a popup box, with an OK button" messageBox MB_OK "WARNING! Please add to your environment variable PATH value '$INSTDIR\lib;$INSTDIR\GnuWin32\bin' before executing Simgrid binaries." SetRebootFlag false # default section end sectionEnd LangString DESC_LibSection ${LANG_ENGLISH} "Install Simgrid libraries with associated headers." LangString DESC_BinSection ${LANG_ENGLISH} "Install some useful tools for Simgrid." LangString DESC_DocSection ${LANG_ENGLISH} "Generated (doxygen) documentation." LangString DESC_ExamplesSection ${LANG_ENGLISH} "Simgrid's HelloWorld example and some classical platforms." LangString DESC_JAVASection ${LANG_ENGLISH} "Install the Java binding and examples." LangString DESC_SMPISection ${LANG_ENGLISH} "Install the SMPI library, headers, and examples." LangString DESC_LibSection ${LANG_FRENCH} "Installer les librairies Simgrid et leurs Ent�tes." LangString DESC_BinSection ${LANG_FRENCH} "Installer les outils optionnels." LangString DESC_DocSection ${LANG_FRENCH} "Installer la documentation." LangString DESC_ExamplesSection ${LANG_FRENCH} "Installer un exemple 'HelloWorld' et des fichiers de plate-formes types." LangString DESC_JAVASection ${LANG_FRENCH} "Installer la librairie Simgrid-java et les exemples." LangString DESC_SMPISection ${LANG_FRENCH} "Installer la librairie SMPI, ses en-t�tes, et ses exemples." !insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN !insertmacro MUI_DESCRIPTION_TEXT ${LibSection} $(DESC_LibSection) !insertmacro MUI_DESCRIPTION_TEXT ${BinSection} $(DESC_BinSection) !insertmacro MUI_DESCRIPTION_TEXT ${DocSection} $(DESC_DocSection) !insertmacro MUI_DESCRIPTION_TEXT ${ExamplesSection} $(DESC_ExamplesSection) !insertmacro MUI_DESCRIPTION_TEXT ${JAVASection} $(DESC_JAVASection) !insertmacro MUI_DESCRIPTION_TEXT ${SMPISection} $(DESC_SMPISection) !insertmacro MUI_FUNCTION_DESCRIPTION_END # create a section to define what the uninstaller does. # the section will always be named "Uninstall" section "Uninstall" # always delete uninstaller first delete $INSTDIR\uninstaller@BIN_EXE@ # delete installed libs delete $INSTDIR\lib\libsimgrid.dll delete $INSTDIR\lib\libsimgrid.def # delete installed bin delete $INSTDIR\bin\colorize delete $INSTDIR\bin\graphicator@BIN_EXE@ delete $INSTDIR\bin\simgrid_update_xml delete $INSTDIR\bin\smpicc delete $INSTDIR\bin\smpif2c delete $INSTDIR\bin\smpiff delete $INSTDIR\bin\smpirun delete $INSTDIR\bin\tesh # delete installed headers delete $INSTDIR\include\xbt.h delete $INSTDIR\include\simgrid_config.h delete $INSTDIR\include\xbt\misc.h delete $INSTDIR\include\xbt\sysdep.h delete $INSTDIR\include\xbt\virtu.h delete $INSTDIR\include\xbt\str.h delete $INSTDIR\include\xbt\strbuff.h delete $INSTDIR\include\xbt\hash.h delete $INSTDIR\include\xbt\function_types.h delete $INSTDIR\include\xbt\asserts.h delete $INSTDIR\include\xbt\ex.h delete $INSTDIR\include\xbt\log.h delete $INSTDIR\include\xbt\module.h delete $INSTDIR\include\xbt\mallocator.h delete $INSTDIR\include\xbt\dynar.h delete $INSTDIR\include\xbt\dict.h delete $INSTDIR\include\xbt\set.h delete $INSTDIR\include\xbt\heap.h delete $INSTDIR\include\xbt\graph.h delete $INSTDIR\include\xbt\fifo.h delete $INSTDIR\include\xbt\swag.h delete $INSTDIR\include\xbt\lib.h delete $INSTDIR\include\xbt\matrix.h delete $INSTDIR\include\xbt\peer.h delete $INSTDIR\include\xbt\config.h delete $INSTDIR\include\xbt\cunit.h delete $INSTDIR\include\xbt\graphxml_parse.h delete $INSTDIR\include\xbt\graphxml.h delete $INSTDIR\include\xbt\time.h delete $INSTDIR\include\xbt\synchro.h delete $INSTDIR\include\xbt\synchro_core.h delete $INSTDIR\include\xbt\queue.h delete $INSTDIR\include\xbt\setset.h delete $INSTDIR\include\xbt\mmalloc.h delete $INSTDIR\include\xbt\replay_trace_reader.h delete $INSTDIR\include\xbt\parmap.h delete $INSTDIR\include\xbt\socket.h delete $INSTDIR\include\xbt\file_stat.h delete $INSTDIR\include\simgrid\platf.h delete $INSTDIR\include\simgrid\modelchecker.h delete $INSTDIR\include\simgrid\simix.h delete $INSTDIR\include\msg\msg.h delete $INSTDIR\include\msg\datatypes.h delete $INSTDIR\include\simdag\simdag.h delete $INSTDIR\include\simdag\datatypes.h delete $INSTDIR\include\smpi\smpi.h delete $INSTDIR\include\smpi\mpi.h delete $INSTDIR\include\smpi\mpif.h delete $INSTDIR\include\smpi\smpi_cocci.h delete $INSTDIR\include\smpi\smpi_main.h delete $INSTDIR\include\smpi\smpif.h delete $INSTDIR\include\surf\surfxml_parse.h delete $INSTDIR\include\surf\simgrid_dtd.h delete $INSTDIR\include\surf\surf_routing.h delete $INSTDIR\include\instr\instr.h # delete EXTRA FILES delete $INSTDIR\AUTHORS delete $INSTDIR\Changelog delete $INSTDIR\COPYING delete $INSTDIR\LICENSE-LGPL-2.1 delete $INSTDIR\NEWS # now delete directories RMDir "$INSTDIR\bin" RMDir "$INSTDIR\lib" RMDir "$INSTDIR\include\simix" RMDir "$INSTDIR\include\instr" RMDir "$INSTDIR\include\surf" RMDir "$INSTDIR\include\smpi" RMDir "$INSTDIR\include\simdag" RMDir "$INSTDIR\include\msg" RMDir "$INSTDIR\include\mc" RMDir "$INSTDIR\include\xbt" RMDir "$INSTDIR\include" RMDir /r "$INSTDIR\doc" RMDir /r "$INSTDIR\examples" RMDir /r "$SMPROGRAMS\SimGrid @SIMGRID_VERSION_MAJOR@.@SIMGRID_VERSION_MINOR@.@SIMGRID_VERSION_PATCH@" # Delete variable DeleteRegValue ${env_hkcu} SIMGRID_ROOT DeleteRegValue ${env_hkcu} SIMGRID_VERSION DeleteRegKey HKCU "SOFTWARE\SimGrid" # delete JAVA-bindings RMDir /r "$INSTDIR\simgrid-java" # delete INSTDIR RMDir /r "$INSTDIR" # uninstall section end sectionEnd SimGrid-3.11/buildtools/Cmake/src/internal_config.h.in000644 001750 001750 00000025741 12342443653 021751 0ustar00cici000000 000000 /* internal_config.h -- characteristics of the platform, as probed by Cmake */ /* This file is AUTOMATICALLY GENERATED by Cmake. Edit the following template instead buildtools/Cmake/src/internal_config.h.in */ /* Copyright (c) 2004-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ /* Set somes variables for Windows compilation */ #ifdef _XBT_DLL_EXPORT #ifndef DLL_EXPORT #define DLL_EXPORT #endif #else #ifdef _XBT_DLL_STATIC #ifndef DLL_STATIC #define DLL_STATIC #endif #else #ifndef DLL_EXPORT #define DLL_IMPORT #endif #endif #endif #cmakedefine SIZEOF_INT @SIZEOF_INT@ #cmakedefine SIZEOF_VOIDP @SIZEOF_VOIDP@ /* If __thread is available */ #cmakedefine HAVE_THREAD_LOCAL_STORAGE @HAVE_THREAD_LOCAL_STORAGE@ #ifndef __STRICT_ANSI__ #cmakedefine __STRICT_ANSI__ @__STRICT_ANSI__@ #endif #ifndef _MSC_VER #cmakedefine _MSC_VER @_MSC_VER@ #endif #ifndef _M_IX86 #cmakedefine _M_IX86 @_M_IX86@ #endif #cmakedefine _XBT_WIN32 @_XBT_WIN32@ //this variable is set if it is a windows platform #cmakedefine _WIN32 @_WIN32@ //this variable is set if it is a 32 bits windows platform #cmakedefine _WIN64 @_WIN64@ //this variable is set if it is a 64 bits windows platform #cmakedefine __VISUALC__ @__VISUALC__@ #cmakedefine __BORLANDC__ @__BORLANDC__@ #cmakedefine APPLE @APPLE@ #ifdef _XBT_WIN32 #ifndef __GNUC__ #cmakedefine __GNUC__ @__GNUC__@ #endif #endif /* Set to true if enable_model-checking is true */ #cmakedefine MMALLOC_WANT_OVERRIDE_LEGACY @MMALLOC_WANT_OVERRIDE_LEGACY@ #cmakedefine HAVE_MC @HAVE_MC@ /* If have linux_futex.h */ #cmakedefine HAVE_FUTEX_H @HAVE_FUTEX_H@ /* Some variable for libsigc++ */ #cmakedefine HAVE_LIBSIGC @HAVE_LIBSIGC++@ /* Some variable for graphviz */ #cmakedefine HAVE_GRAPHVIZ @HAVE_GRAPHVIZ@ #cmakedefine HAVE_GRAPH_H @GRAPH_H@ #cmakedefine HAVE_CGRAPH_H @CGRAPH_H@ #cmakedefine HAVE_AGRAPH_H @AGRAPH_H@ /* Define if building universal (internal helper macro) */ #cmakedefine AC_APPLE_UNIVERSAL_BUILD @AC_APPLE_UNIVERSAL_BUILD@ /* Arguments passed to the configure script */ #cmakedefine AC_CONFIGURE_ARGS @AC_CONFIGURE_ARGS@ /* Path to the addr2line tool */ #cmakedefine ADDR2LINE "@ADDR2LINE@" /* Predefined possible va_copy() implementation (id: ASP) */ #cmakedefine __VA_COPY_USE_ASP(d, s) @__VA_COPY_USE_ASP@ /* Predefined possible va_copy() implementation (id: ASS) */ #cmakedefine __VA_COPY_USE_ASS(d, s) @__VA_COPY_USE_ASS@ /* Predefined possible va_copy() implementation (id: C99) */ #cmakedefine __VA_COPY_USE_C99(d, s) @__VA_COPY_USE_C99@ /* Define if xbt contexts are based on our threads implementation or not */ #cmakedefine CONTEXT_THREADS @CONTEXT_THREADS@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_UCONTEXT_H @HAVE_UCONTEXT_H@ /* Define if xbt contexts are based on ucontext or not */ #cmakedefine CONTEXT_UCONTEXT @CONTEXT_UCONTEXT@ /* Predefined possible va_copy() implementation (id: CPP) */ #cmakedefine __VA_COPY_USE_CPP(d, s) @__VA_COPY_USE_CPP@ /* Predefined possible va_copy() implementation (id: CPS) */ #cmakedefine __VA_COPY_USE_CPS(d, s) @__VA_COPY_USE_CPS@ /* Predefined possible va_copy() implementation (id: GCB) */ #cmakedefine __VA_COPY_USE_GCB(d, s) @__VA_COPY_USE_GCB@ /* Predefined possible va_copy() implementation (id: GCH) */ #cmakedefine __VA_COPY_USE_GCH(d, s) @__VA_COPY_USE_GCH@ /* Predefined possible va_copy() implementation (id: GCM) */ #cmakedefine __VA_COPY_USE_GCM(d, s) @__VA_COPY_USE_GCM@ /* Used to select the flavor of assembly that we need today */ #cmakedefine PROCESSOR_i686 @PROCESSOR_i686@ #cmakedefine PROCESSOR_x86_64 @PROCESSOR_x86_64@ #cmakedefine CMAKE_SYSTEM_PROCESSOR @CMAKE_SYSTEM_PROCESSOR@ #cmakedefine HAVE_RAWCTX @HAVE_RAWCTX@ /* Define to 1 if you have the GNU ld library */ #cmakedefine HAVE_GNU_LD @HAVE_GNU_LD@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_ERRNO_H @HAVE_ERRNO_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_EXECINFO_H @HAVE_EXECINFO_H@ /* Define to 1 if mmalloc is compiled in. */ #cmakedefine HAVE_MMALLOC @HAVE_MMALLOC@ /* Define to 1 if mmap is available */ #cmakedefine HAVE_MMAP @HAVE_MMAP@ /* Define to 1 if you have the `getdtablesize' function. */ #cmakedefine HAVE_GETDTABLESIZE @HAVE_GETDTABLESIZE@ /* Define to 1 if you have the `gettimeofday' function. */ #cmakedefine HAVE_GETTIMEOFDAY @HAVE_GETTIMEOFDAY@ /* Define to 1 if you have the `clock_gettime' function. */ #cmakedefine HAVE_POSIX_GETTIME @HAVE_POSIX_GETTIME@ /* Indicates that we have GTNETS support */ #cmakedefine HAVE_GTNETS @HAVE_GTNETS@ /* Indicates that we have SMPI support */ #cmakedefine HAVE_SMPI @HAVE_SMPI@ /* Indicates that we have SMPI F2C support */ #cmakedefine SMPI_F2C @SMPI_F2C@ /* Indicates that we have NS3 support */ #cmakedefine HAVE_NS3 @HAVE_NS3@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_INTTYPES_H @HAVE_INTTYPES_H@ /* defines whether Lua bindings must be compiled or not */ #cmakedefine HAVE_LUA @HAVE_LUA@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_LUA5_1_LUALIB_H @HAVE_LUA5_1_LUALIB_H@ /* Define to 1 if you have the `makecontext' function. */ #cmakedefine HAVE_MAKECONTEXT @HAVE_MAKECONTEXT@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_MEMORY_H @HAVE_MEMORY_H@ /* Define if pthread_mutex_timedlock() is avaible or not (part of XPG6 standard only?) */ #cmakedefine HAVE_MUTEX_TIMEDLOCK @HAVE_MUTEX_TIMEDLOCK@ /* Define to 1 if you have the `popen' function. */ #cmakedefine HAVE_POPEN @HAVE_POPEN@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_PTHREAD_H @HAVE_PTHREAD_H@ /* Define to 1 if you have the `readv' function. */ #cmakedefine HAVE_READV @HAVE_READV@ /* Define if sem_init() is avaible or not (part of XPG6 standard only) */ #cmakedefine HAVE_SEM_INIT @HAVE_SEM_INIT@ /* Define if sem_timedwait() is avaible or not (part of XPG6 standard only) */ #cmakedefine HAVE_SEM_TIMEDWAIT @HAVE_SEM_TIMEDWAIT@ /* Define to 1 if you have the `signal' function. */ #cmakedefine HAVE_SIGNAL @HAVE_SIGNAL@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SIGNAL_H @HAVE_SIGNAL_H@ /* Define to 1 if you have the `snprintf' function. */ #cmakedefine HAVE_SNPRINTF @HAVE_SNPRINTF@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_STDINT_H @HAVE_STDINT_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_STDLIB_H @HAVE_STDLIB_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_STRINGS_H @HAVE_STRINGS_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_STRING_H @HAVE_STRING_H@ /* Define to 1 if you have the `sysconf' function. */ #cmakedefine HAVE_SYSCONF @HAVE_SYSCONF@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SYS_SOCKET_H @HAVE_SYS_SOCKET_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SYS_STAT_H @HAVE_SYS_STAT_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SYS_TIME_H @HAVE_SYS_TIME_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SYS_TYPES_H @HAVE_SYS_TYPES_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_UNISTD_H @HAVE_UNISTD_H@ /* Define to 1 if you have the `nanosleep' function. */ #cmakedefine HAVE_NANOSLEEP @HAVE_NANOSLEEP@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_VALGRIND_VALGRIND_H @HAVE_VALGRIND_VALGRIND_H@ /* Define if va_copy() macro exists (and no fallback implementation is required) */ #cmakedefine HAVE_VA_COPY @HAVE_VA_COPY@ /* Define to 1 if you have the `vsnprintf' function. */ #cmakedefine HAVE_VSNPRINTF @HAVE_VSNPRINTF@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_WINDOWS_H @HAVE_WINDOWS_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_WINSOCK2_H @HAVE_WINSOCK2_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_WINSOCK_H @HAVE_WINSOCK_H@ /* Define to the sub-directory in which libtool stores uninstalled libraries.*/ #cmakedefine LT_OBJDIR @LT_OBJDIR@ /* enable the asprintf replacement */ #cmakedefine NEED_ASPRINTF @NEED_ASPRINTF@ /* enable the vasprintf replacement */ #cmakedefine NEED_VASPRINTF @NEED_VASPRINTF@ /* Name of package */ #cmakedefine PACKAGE @PACKAGE@ /* Define to the address where bug reports for this package should be sent. */ #cmakedefine PACKAGE_BUGREPORT @PACKAGE_BUGREPORT@ /* Define to the full name of this package. */ #cmakedefine PACKAGE_NAME @PACKAGE_NAME@ /* Define to the full name and version of this package. */ #cmakedefine PACKAGE_STRING @PACKAGE_STRING@ /* Define to the one symbol short name of this package. */ #cmakedefine PACKAGE_TARNAME @PACKAGE_TARNAME@ /* Define to the home page for this package. */ #cmakedefine PACKAGE_URL @PACKAGE_URL@ /* Define to the version of this package. */ #cmakedefine PACKAGE_VERSION @PACKAGE_VERSION@ /* "enable replacement (v)snprintf if system (v)snprintf is broken" */ #cmakedefine PREFER_PORTABLE_SNPRINTF @PREFER_PORTABLE_SNPRINTF@ /* Indicates whether printf("%s",NULL) works */ #cmakedefine PRINTF_NULL_WORKING @PRINTF_NULL_WORKING@ /* define for stack growth */ #cmakedefine PTH_STACKGROWTH @PTH_STACKGROWTH@ /* The maximal size of any scalar on this arch */ #cmakedefine SIZEOF_MAX @SIZEOF_MAX@ /* Define to 1 if you have the ANSI C header files. */ #cmakedefine STDC_HEADERS @STDC_HEADERS@ /* Define to 1 if you can safely include both and . */ #cmakedefine TIME_WITH_SYS_TIME @TIME_WITH_SYS_TIME@ /* Tracing SimGrid */ #cmakedefine HAVE_TRACING @HAVE_TRACING@ /* Tracking of latency bound */ #cmakedefine HAVE_LATENCY_BOUND_TRACKING @HAVE_LATENCY_BOUND_TRACKING@ /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel). */ #if defined AC_APPLE_UNIVERSAL_BUILD # if defined __BIG_ENDIAN__ # define WORDS_BIGENDIAN 1 # endif #else # ifndef WORDS_BIGENDIAN /* # undef WORDS_BIGENDIAN */ # endif #endif /* Define to 1 if `lex' declares `yytext' as a `char *' by default, not a `char[]'. */ #cmakedefine YYTEXT_POINTER /* Optional va_copy() implementation activation */ #ifndef HAVE_VA_COPY #define va_copy(d, s) __VA_COPY_USE(d, s) #endif /* Define to id of used va_copy() implementation */ #cmakedefine __VA_COPY_USE(d, s) @__VA_COPY_USE@ /* Define to empty if `const' does not conform to ANSI C. */ #cmakedefine const @const@ /* Define to `__inline__' or `__inline' if that's what the C compiler calls it, or to nothing if 'inline' is not supported under any name. */ #ifndef __cplusplus #cmakedefine inline @inline@ #endif /* Define to `unsigned int' if does not define. */ #cmakedefine size_t @size_t@ SimGrid-3.11/buildtools/Cmake/UnitTesting.cmake000644 001750 001750 00000003336 12342443653 020516 0ustar00cici000000 000000 # To add a new tested file, simply add the original file in # TEST_CFILES and generated file in TEST_UNITS. The rest is automatic. set(TEST_CFILES src/xbt/cunit.c src/xbt/ex.c src/xbt/dynar.c src/xbt/dict.c src/xbt/set.c src/xbt/swag.c src/xbt/xbt_str.c src/xbt/xbt_strbuff.c src/xbt/xbt_sha.c src/xbt/config.c ) set(TEST_UNITS ${CMAKE_CURRENT_BINARY_DIR}/src/cunit_unit.c ${CMAKE_CURRENT_BINARY_DIR}/src/ex_unit.c ${CMAKE_CURRENT_BINARY_DIR}/src/dynar_unit.c ${CMAKE_CURRENT_BINARY_DIR}/src/dict_unit.c ${CMAKE_CURRENT_BINARY_DIR}/src/set_unit.c ${CMAKE_CURRENT_BINARY_DIR}/src/swag_unit.c ${CMAKE_CURRENT_BINARY_DIR}/src/xbt_str_unit.c ${CMAKE_CURRENT_BINARY_DIR}/src/xbt_strbuff_unit.c ${CMAKE_CURRENT_BINARY_DIR}/src/xbt_sha_unit.c ${CMAKE_CURRENT_BINARY_DIR}/src/config_unit.c ${CMAKE_CURRENT_BINARY_DIR}/src/simgrid_units_main.c ) ADD_CUSTOM_COMMAND( OUTPUT ${TEST_UNITS} DEPENDS ${CMAKE_HOME_DIRECTORY}/tools/sg_unit_extractor.pl ${TEST_CFILES} COMMAND ${CMAKE_COMMAND} -E remove -f ${TEST_UNITS} COMMAND chmod +x ${CMAKE_HOME_DIRECTORY}/tools/sg_unit_extractor.pl COMMAND ${CMAKE_HOME_DIRECTORY}/tools/sg_unit_extractor.pl --root=src/ --outdir=${CMAKE_CURRENT_BINARY_DIR}/src/ ${TEST_CFILES} WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY} COMMENT "Generating *_units files for testall..." ) ### Ensure the build of testall set_source_files_properties(${TEST_UNITS} PROPERTIES GENERATED true) set(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}/src/") add_executable(testall ${TEST_UNITS}) ### Add definitions for compile if(NOT WIN32) target_link_libraries(testall simgrid m) else() target_link_libraries(testall simgrid) endif() add_dependencies(testall ${TEST_UNITS})SimGrid-3.11/buildtools/Cmake/GenerateDoc.cmake000644 001750 001750 00000012003 12342443653 020410 0ustar00cici000000 000000 #### Generate the whole html documentation find_path(DOXYGEN_PATH NAMES doxygen PATHS NO_DEFAULT_PATHS) find_path(JAVADOC_PATH NAMES javadoc PATHS NO_DEFAULT_PATHS) find_path(FIG2DEV_PATH NAMES fig2dev PATHS NO_DEFAULT_PATHS) mark_as_advanced(JAVADOC_PATH) if(DOXYGEN_PATH) ADD_CUSTOM_TARGET(simgrid_documentation COMMENT "Generating the SimGrid documentation..." DEPENDS ${DOC_SOURCES} ${DOC_FIGS} ${source_doxygen} COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_HOME_DIRECTORY}/doc/html COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_HOME_DIRECTORY}/doc/html WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY}/doc ) execute_process(COMMAND ${DOXYGEN_PATH}/doxygen --version OUTPUT_VARIABLE DOXYGEN_VERSION ) message(STATUS "Doxygen version: ${DOXYGEN_VERSION}") if(DOXYGEN_VERSION VERSION_LESS "1.8") ADD_CUSTOM_TARGET(error_doxygen COMMAND ${CMAKE_COMMAND} -E echo "Doxygen must be at least version 1.8 to generate documentation" COMMAND false ) add_dependencies(simgrid_documentation error_doxygen) endif() configure_file(${CMAKE_HOME_DIRECTORY}/doc/Doxyfile.in ${CMAKE_HOME_DIRECTORY}/doc/Doxyfile @ONLY) foreach(file ${DOC_FIGS}) string(REPLACE ".fig" ".png" tmp_file ${file}) string(REPLACE "${CMAKE_HOME_DIRECTORY}/doc/shared/fig/" "${CMAKE_HOME_DIRECTORY}/doc/html/" tmp_file ${tmp_file}) ADD_CUSTOM_COMMAND(TARGET simgrid_documentation COMMAND ${FIG2DEV_PATH}/fig2dev -Lpng -S 4 ${file} ${tmp_file} ) endforeach() foreach(file ${DOC_IMG}) ADD_CUSTOM_COMMAND( TARGET simgrid_documentation COMMAND ${CMAKE_COMMAND} -E copy ${file} ${CMAKE_HOME_DIRECTORY}/doc/html/ ) endforeach() ADD_CUSTOM_COMMAND(TARGET simgrid_documentation COMMAND ${FIG2DEV_PATH}/fig2dev -Lmap ${CMAKE_HOME_DIRECTORY}/doc/shared/fig/simgrid_modules.fig | perl -pe 's/imagemap/simgrid_modules/g'| perl -pe 's/ ${CMAKE_HOME_DIRECTORY}/doc/simgrid_modules.map COMMAND pwd COMMAND ${CMAKE_COMMAND} -E tar czf html/msg-tuto-src.tgz msg-tuto-src/ COMMAND ${CMAKE_COMMAND} -E echo "XX Run doxygen" COMMAND ${DOXYGEN_PATH}/doxygen Doxyfile COMMAND ${CMAKE_COMMAND} -E echo "XX Generate the index files" COMMAND ${CMAKE_HOME_DIRECTORY}/tools/doxygen/index_create.pl simgrid.tag index-API.doc COMMAND ${CMAKE_COMMAND} -E remove ${CMAKE_HOME_DIRECTORY}/doc/doxygen/logcategories.doc COMMAND ${CMAKE_HOME_DIRECTORY}/tools/doxygen/xbt_log_extract_hierarchy.pl > ${CMAKE_HOME_DIRECTORY}/doc/doxygen/logcategories.doc COMMAND ${CMAKE_COMMAND} -E echo "XX Run doxygen again" COMMAND ${DOXYGEN_PATH}/doxygen Doxyfile COMMAND ${CMAKE_COMMAND} -E remove ${CMAKE_HOME_DIRECTORY}/doc/simgrid_modules.map COMMAND ${CMAKE_COMMAND} -E echo "XX Javadoc pass" COMMAND ${JAVADOC_PATH}/javadoc -quiet -d ${CMAKE_HOME_DIRECTORY}/doc/html/javadoc/ ${CMAKE_HOME_DIRECTORY}/src/bindings/java/org/simgrid/*.java ${CMAKE_HOME_DIRECTORY}/src/bindings/java/org/simgrid/*/*.java WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY}/doc ) ADD_CUSTOM_TARGET(pdf COMMAND ${CMAKE_COMMAND} -E echo "XX First pass simgrid_documentation.pdf" COMMAND make clean COMMAND make pdf || true COMMAND ${CMAKE_COMMAND} -E echo "XX Second pass simgrid_documentation.pdf" COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_HOME_DIRECTORY}/doc/latex/refman.pdf COMMAND make pdf || true COMMAND ${CMAKE_COMMAND} -E echo "XX Write Simgrid_documentation.pdf" COMMAND ${CMAKE_COMMAND} -E rename ${CMAKE_HOME_DIRECTORY}/doc/latex/refman.pdf ${CMAKE_HOME_DIRECTORY}/doc/latex/simgrid_documentation.pdf WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY}/doc/latex/ ) add_dependencies(pdf simgrid_documentation) endif() ############################################# ### Fill in the "make sync-gforge" target ### ############################################# set(RSYNC_CMD rsync --verbose --cvs-exclude --compress --delete --delete-excluded --rsh=ssh --ignore-times --recursive --links --times --omit-dir-times --perms --chmod=a+rX,ug+w,o-w,Dg+s) add_custom_target(sync-gforge-doc COMMAND ssh scm.gforge.inria.fr mkdir -p -m 2775 /home/groups/simgrid/htdocs/simgrid/${release_version}/ || true COMMAND ${RSYNC_CMD} doc/html/ scm.gforge.inria.fr:/home/groups/simgrid/htdocs/simgrid/${release_version}/doc/ || true COMMAND ${RSYNC_CMD} doc/html/simgrid_modules2.png doc/html/simgrid_modules.png doc/webcruft/simgrid_logo_2011.png doc/webcruft/simgrid_logo_2011_small.png scm.gforge.inria.fr:/home/groups/simgrid/htdocs/simgrid/${release_version}/ WORKING_DIRECTORY "${CMAKE_HOME_DIRECTORY}" ) add_dependencies(sync-gforge-doc simgrid_documentation) add_custom_target(sync-gforge-dtd COMMAND ${RSYNC_CMD} src/surf/simgrid.dtd scm.gforge.inria.fr:/home/groups/simgrid/htdocs/simgrid/${release_version}/simgrid.dtd COMMAND ${RSYNC_CMD} src/surf/simgrid.dtd scm.gforge.inria.fr:/home/groups/simgrid/htdocs/simgrid.dtd WORKING_DIRECTORY "${CMAKE_HOME_DIRECTORY}" ) SimGrid-3.11/buildtools/Cmake/MakeLibWin.cmake000644 001750 001750 00000003073 12342443653 020221 0ustar00cici000000 000000 ### Make Libs #>gcc c:\simgrid-trunk\examples\msg\icomms\peer.c -static -Lc:\simgrid-trunk\lib -lsimgrid -Ic:\simgrid-trunk\include -lwsock32 if(enable_java) include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/MakeJava.cmake) endif() add_library(simgrid SHARED ${simgrid_sources}) set_target_properties(simgrid PROPERTIES COMPILE_FLAGS "-D_XBT_DLL_EXPORT -DDLL_EXPORT" LINK_FLAGS "-shared" VERSION ${libsimgrid_version} PREFIX "lib" SUFFIX ".dll" IMPORT_PREFIX "lib" IMPORT_SUFFIX ".dll") # libpthreadGC2.dll if(ARCH_32_BITS) find_library(PATH_PTHREAD_LIB NAMES pthreadGC2.dll HINTS $ENV{PATH} PATH_SUFFIXES bin/ c/bin ) else() find_library(PATH_PTHREAD_LIB NAMES pthreadGC2-w64.dll HINTS $ENV{PATH} PATH_SUFFIXES bin/ c/bin ) endif() set(SIMGRID_DEP "-lws2_32 -L${PATH_PTHREAD_LIB} -lm -lpthreadGC2") if(ARCH_32_BITS) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32 -march=i486 -D_I_X86_") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32 -march=i486 -D_I_X86_") else() set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m64 -D_AMD64_") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m64 -D_AMD64_") # message(FATAL_ERROR "Sorry, Simgrid fails with full 64bits for now! Please contact us.") endif() target_link_libraries(simgrid ${SIMGRID_DEP}) find_path(PEXPORTS_PATH NAMES pexports.exe PATHS NO_DEFAULT_PATHS) message(STATUS "pexports: ${PEXPORTS_PATH}") if(PEXPORTS_PATH) add_custom_command(TARGET simgrid POST_BUILD COMMAND ${PEXPORTS_PATH}/pexports.exe ${CMAKE_BINARY_DIR}/lib/libsimgrid.dll > ${CMAKE_BINARY_DIR}/lib/libsimgrid.def) endif() SimGrid-3.11/buildtools/Cmake/Distrib.cmake000644 001750 001750 00000037017 12342443653 017644 0ustar00cici000000 000000 ######################################### ### Fill in the "make install" target ### ######################################### # doc file(MAKE_DIRECTORY ${CMAKE_HOME_DIRECTORY}/doc/html/) install(DIRECTORY "${CMAKE_HOME_DIRECTORY}/doc/html/" DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/doc/simgrid/html/) install(DIRECTORY "${CMAKE_HOME_DIRECTORY}/doc/HelloWorld/" DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/doc/simgrid/HelloWorld/) #### Generate the manpages if(NOT WIN32) if( NOT MANPAGE_DIR) set( MANPAGE_DIR ${CMAKE_BINARY_DIR}/manpages ) endif() add_custom_target(manpages ALL COMMAND ${CMAKE_COMMAND} -E make_directory ${MANPAGE_DIR} COMMAND pod2man ${CMAKE_HOME_DIRECTORY}/tools/simgrid_update_xml.pl > ${MANPAGE_DIR}/simgrid_update_xml.1 COMMENT "Generating manpages" ) install(FILES ${MANPAGE_DIR}/simgrid_update_xml.1 ${CMAKE_HOME_DIRECTORY}/tools/tesh/tesh.1 ${CMAKE_HOME_DIRECTORY}/doc/manpage/smpirun.1 ${CMAKE_HOME_DIRECTORY}/doc/manpage/smpicc.1 DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/share/man/man1) endif() # binaries if(enable_smpi) install(PROGRAMS ${CMAKE_BINARY_DIR}/bin/smpicc ${CMAKE_BINARY_DIR}/bin/smpicxx ${CMAKE_BINARY_DIR}/bin/smpirun DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/) if(SMPI_F2C) install(PROGRAMS ${CMAKE_BINARY_DIR}/bin/smpif2c ${CMAKE_BINARY_DIR}/bin/smpiff DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/) endif() if(SMPI_F90) install(PROGRAMS ${CMAKE_BINARY_DIR}/bin/smpif90 DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/) endif() endif() install(PROGRAMS ${CMAKE_BINARY_DIR}/bin/tesh DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/) install(PROGRAMS ${CMAKE_BINARY_DIR}/bin/graphicator DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/) install(PROGRAMS ${CMAKE_HOME_DIRECTORY}/tools/MSG_visualization/colorize.pl DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/ RENAME simgrid-colorizer) add_custom_target(simgrid-colorizer ALL COMMENT "Install ${CMAKE_BINARY_DIR}/bin/colorize" COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_HOME_DIRECTORY}/tools/MSG_visualization/colorize.pl ${CMAKE_BINARY_DIR}/bin/colorize ) install(PROGRAMS ${CMAKE_HOME_DIRECTORY}/tools/simgrid_update_xml.pl DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/ RENAME simgrid_update_xml) add_custom_target(simgrid_update_xml ALL COMMENT "Install ${CMAKE_BINARY_DIR}/bin/simgrid_update_xml" COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_HOME_DIRECTORY}/tools/simgrid_update_xml.pl ${CMAKE_BINARY_DIR}/bin/simgrid_update_xml ) # libraries install(TARGETS simgrid DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib/) if(enable_lib_static AND NOT WIN32) install(TARGETS simgrid_static DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib/) endif() if(enable_java) if(enable_lib_in_jar) set(SIMGRID_JAR_TO_INSTALL "${SIMGRID_FULL_JAR}") else() set(SIMGRID_JAR_TO_INSTALL "${SIMGRID_JAR}") endif() install(TARGETS simgrid-java DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib/) install(FILES ${SIMGRID_JAR_TO_INSTALL} DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/java/ RENAME simgrid.jar) endif() # include files set(HEADERS ${headers_to_install} ${generated_headers_to_install} ) foreach(file ${HEADERS}) get_filename_component(location ${file} PATH) string(REPLACE "${CMAKE_CURRENT_BINARY_DIR}/" "" location "${location}") install(FILES ${file} DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/${location}) endforeach(file ${HEADERS}) # example files foreach(file ${examples_to_install}) string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/examples/" "" file ${file}) get_filename_component(location ${file} PATH) install(FILES "examples/${file}" DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/doc/simgrid/examples/${location}) endforeach(file ${examples_to_install}) # bindings cruft if(HAVE_LUA) file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/lib/lua/5.1") add_custom_target(simgrid_lua ALL DEPENDS simgrid ${CMAKE_BINARY_DIR}/lib/lua/5.1/simgrid.${LIB_EXE} ) add_custom_command( OUTPUT ${CMAKE_BINARY_DIR}/lib/lua/5.1/simgrid.${LIB_EXE} COMMAND ${CMAKE_COMMAND} -E create_symlink ../../libsimgrid.${LIB_EXE} ${CMAKE_BINARY_DIR}/lib/lua/5.1/simgrid.${LIB_EXE} ) install(FILES ${CMAKE_BINARY_DIR}/lib/lua/5.1/simgrid.${LIB_EXE} DESTINATION $ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib/lua/5.1 ) endif() ########################################### ### Fill in the "make uninstall" target ### ########################################### add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_INSTALL_PREFIX}/doc/simgrid COMMAND ${CMAKE_COMMAND} -E echo "uninstall doc ok" COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/lib/libsimgrid* COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/lib/lua/5.1/simgrid* COMMAND ${CMAKE_COMMAND} -E echo "uninstall lib ok" COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/bin/smpicc COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/bin/smpicxx COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/bin/smpif2c COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/bin/smpiff COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/bin/smpif90 COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/bin/smpirun COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/bin/tesh COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/bin/simgrid-colorizer COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/bin/simgrid_update_xml COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/bin/graphicator COMMAND ${CMAKE_COMMAND} -E echo "uninstall bin ok" COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_INSTALL_PREFIX}/include/instr COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_INSTALL_PREFIX}/include/msg COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_INSTALL_PREFIX}/include/simdag COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_INSTALL_PREFIX}/include/smpi COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_INSTALL_PREFIX}/include/simix COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_INSTALL_PREFIX}/include/surf COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_INSTALL_PREFIX}/include/xbt COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_INSTALL_PREFIX}/include/mc COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_INSTALL_PREFIX}/include/simgrid COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/include/simgrid.h COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/include/simgrid_config.h COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/include/xbt.h COMMAND ${CMAKE_COMMAND} -E echo "uninstall include ok" COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/share/man/man1/simgrid_update_xml.1 COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/share/man/man1/tesh.1 COMMAND ${CMAKE_COMMAND} -E echo "uninstall man ok" WORKING_DIRECTORY "${CMAKE_INSTALL_PREFIX}" ) if(HAVE_LUA) add_custom_command(TARGET uninstall COMMAND ${CMAKE_COMMAND} -E echo "uninstall binding lua ok" COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_INSTALL_PREFIX}/lib/lua/5.1/simgrid.${LIB_EXE} WORKING_DIRECTORY "${CMAKE_HOME_DIRECTORY}/" ) endif() ################################################################ ## Build a sain "make dist" target to build a source package ### ## containing only the files that I explicitely state ### ## (instead of any cruft laying on my disk as CPack does) ### ################################################################ # This is the complete list of what will be added to the source archive set(source_to_pack ${headers_to_install} ${source_of_generated_headers} ${BINDINGS_SRC} ${GTNETS_SRC} ${JEDULE_SRC} ${JMSG_C_SRC} ${JMSG_JAVA_SRC} ${JSURF_SWIG_SRC} ${JSURF_SWIG_SRC_EXTRA} ${JSURF_C_SRC} ${LUA_SRC} ${MC_SRC} ${MSG_SRC} ${NS3_SRC} ${RNGSTREAM_SRC} ${SIMDAG_SRC} ${SIMGRID_SRC} ${SIMIX_SRC} ${SMPI_SRC} ${SURF_SRC} ${TRACING_SRC} ${XBT_RL_SRC} ${XBT_SRC} ${EXTRA_DIST} ${CMAKE_SOURCE_FILES} ${EXAMPLES_CMAKEFILES_TXT} ${TESHSUITE_CMAKEFILES_TXT} ${TOOLS_CMAKEFILES_TXT} ${DOC_FIGS} ${DOC_IMG} ${DOC_SOURCES} ${DOC_TOOLS} ${PLATFORMS_EXAMPLES} ${README_files} ${bin_files} ${examples_src} ${tesh_files} ${teshsuite_src} ${testsuite_src} ${tools_src} ${txt_files} ${xml_files} ) ########################################## ### Fill in the "make dist-dir" target ### ########################################## add_custom_target(dist-dir COMMENT "Generating the distribution directory" COMMAND ${CMAKE_COMMAND} -E remove_directory ${PROJECT_NAME}-${release_version}/ COMMAND ${CMAKE_COMMAND} -E remove ${PROJECT_NAME}-${release_version}.tar.gz COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_NAME}-${release_version} COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_NAME}-${release_version}/doc/html/ COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_HOME_DIRECTORY}/doc/html/ ${PROJECT_NAME}-${release_version}/doc/html/ ) add_dependencies(dist-dir simgrid_documentation) add_dependencies(dist-dir maintainer_files) set(dirs_in_tarball "") foreach(file ${source_to_pack}) #message(${file}) # This damn prefix is still set somewhere (seems to be in subdirs) string(REPLACE "${CMAKE_HOME_DIRECTORY}/" "" file "${file}") # Create the directory on need get_filename_component(file_location ${file} PATH) string(REGEX MATCH ";${file_location};" OPERATION "${dirs_in_tarball}") if(NOT OPERATION) set(dirs_in_tarball "${dirs_in_tarball};${file_location};") add_custom_command( TARGET dist-dir COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_NAME}-${release_version}/${file_location}/ ) endif() # Actually copy the file add_custom_command( TARGET dist-dir COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_HOME_DIRECTORY}/${file} ${PROJECT_NAME}-${release_version}/${file_location} ) endforeach(file ${source_to_pack}) add_custom_command( TARGET dist-dir COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Scripts/Makefile.default ${PROJECT_NAME}-${release_version}/Makefile COMMAND ${CMAKE_COMMAND} -E echo "${GIT_VERSION}" > ${PROJECT_NAME}-${release_version}/.gitversion ) ###################################### ### Fill in the "make dist" target ### ###################################### add_custom_target(dist COMMENT "Removing the distribution directory" DEPENDS ${CMAKE_BINARY_DIR}/${PROJECT_NAME}-${release_version}.tar.gz COMMAND ${CMAKE_COMMAND} -E echo ${PROJECT_NAME}-${release_version} > ${CMAKE_BINARY_DIR}/VERSION COMMAND ${CMAKE_COMMAND} -E remove_directory ${PROJECT_NAME}-${release_version}/ ) add_custom_command( OUTPUT ${CMAKE_BINARY_DIR}/${PROJECT_NAME}-${release_version}.tar.gz COMMENT "Compressing the archive from the distribution directory" COMMAND ${CMAKE_COMMAND} -E tar cf ${PROJECT_NAME}-${release_version}.tar ${PROJECT_NAME}-${release_version}/ COMMAND gzip -9v ${PROJECT_NAME}-${release_version}.tar COMMAND ${CMAKE_COMMAND} -E remove_directory ${PROJECT_NAME}-${release_version}/ ) add_dependencies(dist dist-dir) if(NOT enable_maintainer_mode) add_custom_target(echo-dist COMMAND ${CMAKE_COMMAND} -E echo "WARNING: ----------------------------------------------------" COMMAND ${CMAKE_COMMAND} -E echo "WARNING: Distrib is generated without option maintainer mode " COMMAND ${CMAKE_COMMAND} -E echo "WARNING: ----------------------------------------------------" ) add_dependencies(dist echo-dist) endif() ########################################### ### Fill in the "make distcheck" target ### ########################################### set(CMAKE_BINARY_TEST_DIR ${CMAKE_BINARY_DIR}) # Allow to test the "make dist" add_custom_target(distcheck COMMAND ${CMAKE_COMMAND} -E echo "XXX compare archive with git repository" COMMAND ${CMAKE_HOME_DIRECTORY}/tools/check_dist_archive -batch ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}.tar.gz COMMAND ${CMAKE_COMMAND} -E echo "XXX remove old copy" COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version} COMMAND ${CMAKE_COMMAND} -E echo "XXX Untar distrib" COMMAND ${CMAKE_COMMAND} -E tar xf ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}.tar.gz ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version} COMMAND ${CMAKE_COMMAND} -E echo "XXX create build and install subtrees" COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}/_build COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}/_inst COMMAND ${CMAKE_COMMAND} -E echo "XXX Configure" COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}/_build ${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}/_inst .. COMMAND ${CMAKE_COMMAND} -E echo "XXX Build" COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}/_build ${CMAKE_MAKE_PROGRAM} COMMAND ${CMAKE_COMMAND} -E echo "XXX Test" COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}/_build ctest --output-on-failure COMMAND ${CMAKE_COMMAND} -E echo "XXX Install" COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}/_build ${CMAKE_MAKE_PROGRAM} install COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}/_inst/lib/libsimgrid.so ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}/_inst/lib/libsimgridtest.so COMMAND ${CMAKE_COMMAND} -E echo "XXX Build documentation" COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}/_build ${CMAKE_MAKE_PROGRAM} simgrid_documentation COMMAND ${CMAKE_COMMAND} -E echo "XXX Install with documentation" COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version}/_build ${CMAKE_MAKE_PROGRAM} install COMMAND ${CMAKE_COMMAND} -E echo "XXX Remove temp directories" COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_BINARY_TEST_DIR}/${PROJECT_NAME}-${release_version} ) add_dependencies(distcheck dist) ####################################### ### Fill in the "make check" target ### ####################################### if(enable_memcheck) add_custom_target(check COMMAND ctest -D ExperimentalMemCheck ) else() add_custom_target(check COMMAND make test ) endif() ####################################### ### Fill in the "make xxx-clean" target ### ####################################### add_custom_target(maintainer-clean COMMAND ${CMAKE_COMMAND} -E remove -f src/config_unit.c COMMAND ${CMAKE_COMMAND} -E remove -f src/cunit_unit.c COMMAND ${CMAKE_COMMAND} -E remove -f src/dict_unit.c COMMAND ${CMAKE_COMMAND} -E remove -f src/dynar_unit.c COMMAND ${CMAKE_COMMAND} -E remove -f src/ex_unit.c COMMAND ${CMAKE_COMMAND} -E remove -f src/set_unit.c COMMAND ${CMAKE_COMMAND} -E remove -f src/simgrid_units_main.c COMMAND ${CMAKE_COMMAND} -E remove -f src/swag_unit.c COMMAND ${CMAKE_COMMAND} -E remove -f src/xbt_sha_unit.c COMMAND ${CMAKE_COMMAND} -E remove -f src/xbt_str_unit.c COMMAND ${CMAKE_COMMAND} -E remove -f src/xbt_strbuff_unit.c COMMAND ${CMAKE_COMMAND} -E remove -f src/xbt_synchro_unit.c WORKING_DIRECTORY "${CMAKE_HOME_DIRECTORY}" ) include(CPack) SimGrid-3.11/buildtools/Cmake/Flags.cmake000644 001750 001750 00000007430 12342443653 017274 0ustar00cici000000 000000 set(warnCFLAGS "") set(optCFLAGS "") if(NOT __VISUALC__ AND NOT __BORLANDC__) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}-std=gnu99 -g3") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}-g3") set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -g") else() set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}/Zi") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}/Zi") endif() if(enable_compile_warnings) set(warnCFLAGS "-fno-common -Wall -Wunused -Wmissing-prototypes -Wmissing-declarations -Wpointer-arith -Wchar-subscripts -Wcomment -Wformat -Wwrite-strings -Wno-unused-function -Wno-unused-parameter -Wno-strict-aliasing -Wno-format-nonliteral -Werror ") if(CMAKE_C_COMPILER_ID STREQUAL "GNU") set(warnCFLAGS "${warnCFLAGS}-Wclobbered -Wno-error=clobbered ") if(COMPILER_C_VERSION_MAJOR_MINOR STRGREATER "4.5") set(warnCFLAGS "${warnCFLAGS}-Wno-error=unused-but-set-variable ") endif() endif() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-unused-function -Wno-unused-parameter -Wno-strict-aliasing -Wno-format-nonliteral -Werror") set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -Wall") # FIXME: Q&D hack set(CMAKE_JAVA_COMPILE_FLAGS "-Xlint") endif() if(enable_compile_optimizations) set(optCFLAGS "-O3 -finline-functions -funroll-loops -fno-strict-aliasing ") if(CMAKE_COMPILER_IS_GNUCC) if(WIN32) if (COMPILER_C_VERSION_MAJOR_MINOR STRGREATER "4.7") # On windows, we need 4.8 or higher to enable lto because of http://gcc.gnu.org/bugzilla/show_bug.cgi?id=50293 set(optCFLAGS "${optCFLAGS} -flto ") endif() else() # On non-windows, 4.6 is enough for that if(COMPILER_C_VERSION_MAJOR_MINOR STRGREATER "4.5" AND LINKER_VERSION STRGREATER "2.22") set(optCFLAGS "${optCFLAGS} -flto ") endif() endif() endif() else() set(optCFLAGS "-O0 ") endif() if(APPLE AND COMPILER_C_VERSION_MAJOR_MINOR MATCHES "4.6") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-deprecated-declarations") set(optCFLAGS "-O0 ") endif() if(NOT enable_debug) set(CMAKE_C_FLAGS "-DNDEBUG ${CMAKE_C_FLAGS}") endif() if(enable_msg_deprecated) set(CMAKE_C_FLAGS "-DMSG_USE_DEPRECATED ${CMAKE_C_FLAGS}") endif() set(CMAKE_C_FLAGS "${optCFLAGS}${warnCFLAGS}${CMAKE_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${optCFLAGS}") # Try to make Mac a bit more complient to open source standards if(CMAKE_SYSTEM_NAME MATCHES "Darwin") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_XOPEN_SOURCE") endif() set(TESH_OPTION "") if(enable_coverage) find_program(GCOV_PATH gcov) if(GCOV_PATH) set(COVERAGE_COMMAND "${GCOV_PATH}" CACHE TYPE FILEPATH FORCE) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DCOVERAGE") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage") set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -fprofile-arcs -ftest-coverage") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage") set(TESH_OPTION --enable-coverage) add_definitions(-fprofile-arcs -ftest-coverage) endif() endif() if(NOT $ENV{CFLAGS} STREQUAL "") message(STATUS "Add CFLAGS: \"$ENV{CFLAGS}\" to CMAKE_C_FLAGS") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} $ENV{CFLAGS}") endif() if(NOT $ENV{CXXFLAGS} STREQUAL "") message(STATUS "Add CXXFLAGS: \"$ENV{CXXFLAGS}\" to CMAKE_CXX_FLAGS") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} $ENV{CXXFLAGS}") endif() if(NOT $ENV{LDFLAGS} STREQUAL "") message(STATUS "Add LDFLAGS: \"$ENV{LDFLAGS}\" to CMAKE_C_LINK_FLAGS") set(CMAKE_C_LINK_FLAGS "${CMAKE_C_LINK_FLAGS} $ENV{LDFLAGS}") endif() if(enable_model-checking AND enable_compile_optimizations) message(WARNING "Sorry for now GCC optimizations does not work with model checking.\nPlease turn off optimizations with command:\ncmake -Denable_compile_optimizations=off .") endif() SimGrid-3.11/buildtools/Cmake/DefinePackages.cmake000644 001750 001750 00000106106 12342443653 021071 0ustar00cici000000 000000 ### define source packages set(EXTRA_DIST src/bindings/java/MANIFEST.MF.in src/include/instr/instr_interface.h src/include/mc/datatypes.h src/include/mc/mc.h src/include/simgrid/platf_interface.h src/include/simgrid/sg_config.h src/include/smpi/smpi_interface.h src/include/surf/datatypes.h src/include/surf/maxmin.h src/include/surf/random_mgr.h src/include/surf/surf.h src/include/surf/surf_resource.h src/include/surf/surf_resource_lmm.h src/include/surf/surfxml_parse_values.h src/include/surf/trace_mgr.h src/include/xbt/win32_ucontext.h src/include/xbt/wine_dbghelp.h src/msg/msg_mailbox.h src/msg/msg_private.h src/portable.h src/simdag/dax.dtd src/simdag/dax_dtd.c src/simdag/dax_dtd.h src/simdag/private.h src/simix/simcalls.in src/simix/simcalls.py src/simix/simcalls_generated_args_getter_setter.h src/simix/simcalls_generated_body.c src/simix/simcalls_generated_case.c src/simix/simcalls_generated_enum.h src/simix/simcalls_generated_res_getter_setter.h src/simix/simcalls_generated_string.c src/simix/smx_host_private.h src/simix/smx_io_private.h src/simix/smx_network_private.h src/simix/smx_private.h src/simix/smx_process_private.h src/simix/smx_smurf_private.h src/simix/smx_synchro_private.h src/smpi/README src/smpi/colls/coll_tuned_topo.h src/smpi/colls/colls.h src/smpi/colls/colls_private.h src/smpi/private.h src/smpi/smpi_mpi_dt_private.h src/surf/cpu_cas01.hpp src/surf/cpu_interface.hpp src/surf/cpu_ti.hpp src/surf/gtnets/gtnets_interface.h src/surf/gtnets/gtnets_simulator.h src/surf/gtnets/gtnets_topology.h src/surf/maxmin_private.hpp src/surf/network_cm02.hpp src/surf/network_constant.hpp src/surf/network_gtnets.hpp src/surf/network_interface.hpp src/surf/network_ns3.hpp src/surf/network_smpi.hpp src/surf/ns3/my-point-to-point-helper.h src/surf/ns3/ns3_interface.h src/surf/ns3/ns3_simulator.h src/surf/ns3/red-queue.h src/surf/platf_generator_private.h src/surf/plugins/energy.hpp src/surf/simgrid.dtd src/surf/simgrid_dtd.c src/surf/storage_interface.hpp src/surf/storage_n11.hpp src/surf/surf_interface.hpp src/surf/surf_private.h src/surf/surf_routing.hpp src/surf/surf_routing_cluster.hpp src/surf/surf_routing_cluster_fat_tree.hpp src/surf/surf_routing_cluster_torus.hpp src/surf/surf_routing_dijkstra.hpp src/surf/surf_routing_floyd.hpp src/surf/surf_routing_full.hpp src/surf/surf_routing_generic.hpp src/surf/surf_routing_none.hpp src/surf/surf_routing_private.hpp src/surf/surf_routing_vivaldi.hpp src/surf/surfxml_parse.c src/surf/trace_mgr_private.h src/surf/vm_workstation_hl13.hpp src/surf/vm_workstation_interface.hpp src/surf/workstation_clm03.hpp src/surf/workstation_interface.hpp src/surf/workstation_ptask_L07.hpp src/win32/config.h src/xbt/automaton/automaton_lexer.yy.c src/xbt/automaton/parserPromela.lex src/xbt/automaton/parserPromela.tab.cacc src/xbt/automaton/parserPromela.tab.hacc src/xbt/automaton/parserPromela.yacc src/xbt/backtrace_dummy.c src/xbt/backtrace_linux.c src/xbt/backtrace_windows.c src/xbt/dict_private.h src/xbt/ex_interface.h src/xbt/fifo_private.h src/xbt/graph_private.h src/xbt/graphxml.c src/xbt/graphxml.dtd src/xbt/graphxml_parse.c src/xbt/heap_private.h src/xbt/log_private.h src/xbt/mallocator_private.h src/xbt/mmalloc/mfree.c src/xbt/mmalloc/mm.c src/xbt/mmalloc/mm_diff.c src/xbt/mmalloc/mm_legacy.c src/xbt/mmalloc/mm_module.c src/xbt/mmalloc/mmalloc.c src/xbt/mmalloc/mmalloc.info src/xbt/mmalloc/mmalloc.texi src/xbt/mmalloc/mmorecore.c src/xbt/mmalloc/mmprivate.h src/xbt/mmalloc/mmtrace.awk src/xbt/mmalloc/mrealloc.c src/xbt/setset_private.h src/xbt/win32_ucontext.c tools/tesh/run_context.h tools/tesh/tesh.h ) set(SMPI_SRC src/smpi/colls/allgather-2dmesh.c src/smpi/colls/allgather-3dmesh.c src/smpi/colls/allgather-GB.c src/smpi/colls/allgather-NTSLR-NB.c src/smpi/colls/allgather-NTSLR.c src/smpi/colls/allgather-SMP-NTS.c src/smpi/colls/allgather-bruck.c src/smpi/colls/allgather-loosely-lr.c src/smpi/colls/allgather-ompi-neighborexchange.c src/smpi/colls/allgather-pair.c src/smpi/colls/allgather-rdb.c src/smpi/colls/allgather-rhv.c src/smpi/colls/allgather-ring.c src/smpi/colls/allgather-smp-simple.c src/smpi/colls/allgather-spreading-simple.c src/smpi/colls/allgatherv-GB.c src/smpi/colls/allgatherv-mpich-rdb.c src/smpi/colls/allgatherv-mpich-ring.c src/smpi/colls/allgatherv-ompi-bruck.c src/smpi/colls/allgatherv-ompi-neighborexchange.c src/smpi/colls/allgatherv-pair.c src/smpi/colls/allgatherv-ring.c src/smpi/colls/allreduce-lr.c src/smpi/colls/allreduce-ompi-ring-segmented.c src/smpi/colls/allreduce-rab-rdb.c src/smpi/colls/allreduce-rab1.c src/smpi/colls/allreduce-rab2.c src/smpi/colls/allreduce-rdb.c src/smpi/colls/allreduce-redbcast.c src/smpi/colls/allreduce-smp-binomial-pipeline.c src/smpi/colls/allreduce-smp-binomial.c src/smpi/colls/allreduce-smp-rdb.c src/smpi/colls/allreduce-smp-rsag-lr.c src/smpi/colls/allreduce-smp-rsag-rab.c src/smpi/colls/allreduce-smp-rsag.c src/smpi/colls/alltoall-2dmesh.c src/smpi/colls/alltoall-3dmesh.c # src/smpi/colls/alltoall-bruck.c src/smpi/colls/alltoall-pair-light-barrier.c src/smpi/colls/alltoall-pair-mpi-barrier.c src/smpi/colls/alltoall-pair-one-barrier.c src/smpi/colls/alltoall-pair.c src/smpi/colls/alltoall-rdb.c src/smpi/colls/alltoall-ring-light-barrier.c src/smpi/colls/alltoall-ring-mpi-barrier.c src/smpi/colls/alltoall-ring-one-barrier.c src/smpi/colls/alltoall-ring.c src/smpi/colls/alltoallv-bruck.c src/smpi/colls/alltoallv-ompi-basic-linear.c src/smpi/colls/alltoallv-pair-light-barrier.c src/smpi/colls/alltoallv-pair-mpi-barrier.c src/smpi/colls/alltoallv-pair-one-barrier.c src/smpi/colls/alltoallv-pair.c src/smpi/colls/alltoallv-ring-light-barrier.c src/smpi/colls/alltoallv-ring-mpi-barrier.c src/smpi/colls/alltoallv-ring-one-barrier.c src/smpi/colls/alltoallv-ring.c src/smpi/colls/barrier-ompi.c src/smpi/colls/bcast-NTSB.c src/smpi/colls/bcast-NTSL-Isend.c src/smpi/colls/bcast-NTSL.c src/smpi/colls/bcast-SMP-binary.c src/smpi/colls/bcast-SMP-binomial.c src/smpi/colls/bcast-SMP-linear.c src/smpi/colls/bcast-arrival-pattern-aware-wait.c src/smpi/colls/bcast-arrival-pattern-aware.c src/smpi/colls/bcast-arrival-scatter.c src/smpi/colls/bcast-binomial-tree.c src/smpi/colls/bcast-flattree-pipeline.c src/smpi/colls/bcast-flattree.c src/smpi/colls/bcast-ompi-pipeline.c src/smpi/colls/bcast-ompi-split-bintree.c src/smpi/colls/bcast-scatter-LR-allgather.c src/smpi/colls/bcast-scatter-rdb-allgather.c src/smpi/colls/coll_tuned_topo.c src/smpi/colls/colls_global.c src/smpi/colls/gather-ompi.c src/smpi/colls/reduce-NTSL.c src/smpi/colls/reduce-arrival-pattern-aware.c src/smpi/colls/reduce-binomial.c src/smpi/colls/reduce-flat-tree.c src/smpi/colls/reduce-ompi.c src/smpi/colls/reduce-scatter-gather.c src/smpi/colls/reduce_scatter-mpich.c src/smpi/colls/reduce_scatter-ompi.c src/smpi/colls/scatter-ompi.c src/smpi/colls/smpi_automatic_selector.c src/smpi/colls/smpi_mpich_selector.c src/smpi/colls/smpi_openmpi_selector.c src/smpi/instr_smpi.c src/smpi/smpi_base.c src/smpi/smpi_bench.c src/smpi/smpi_c99.c src/smpi/smpi_coll.c src/smpi/smpi_comm.c src/smpi/smpi_deployment.c src/smpi/smpi_dvfs.c src/smpi/smpi_global.c src/smpi/smpi_group.c src/smpi/smpi_mpi.c src/smpi/smpi_mpi_dt.c src/smpi/smpi_pmpi.c src/smpi/smpi_replay.c src/smpi/smpi_topo.c ) if(SMPI_F2C) set(SMPI_SRC ${SMPI_SRC} src/smpi/smpi_f77.c ) else() set(EXTRA_DIST ${EXTRA_DIST} src/smpi/smpi_f77.c ) endif() set(XBT_SRC src/xbt/RngStream.c src/xbt/automaton/automaton.c src/xbt/automaton/automatonparse_promela.c src/xbt/config.c src/xbt/cunit.c src/xbt/dict.c src/xbt/dict_cursor.c src/xbt/dict_elm.c src/xbt/dict_multi.c src/xbt/dynar.c src/xbt/ex.c src/xbt/fifo.c src/xbt/graph.c src/xbt/graphxml_parse.c src/xbt/heap.c src/xbt/lib.c src/xbt/log.c src/xbt/mallocator.c src/xbt/parmap.c src/xbt/set.c src/xbt/setset.c src/xbt/snprintf.c src/xbt/swag.c src/xbt/xbt_log_appender_file.c src/xbt/xbt_log_layout_format.c src/xbt/xbt_log_layout_simple.c src/xbt/xbt_main.c src/xbt/xbt_matrix.c src/xbt/xbt_os_time.c src/xbt/xbt_peer.c src/xbt/xbt_queue.c src/xbt/xbt_replay.c src/xbt/xbt_sg_synchro.c src/xbt/xbt_sha.c src/xbt/xbt_str.c src/xbt/xbt_strbuff.c src/xbt/xbt_virtu.c src/xbt_modinter.h ) if(HAVE_MMALLOC) set(XBT_SRC ${XBT_SRC} src/xbt/mmalloc/mm.c ) endif() set(GTNETS_SRC src/surf/gtnets/gtnets_interface.cc src/surf/gtnets/gtnets_simulator.cc src/surf/gtnets/gtnets_topology.cc src/surf/network_gtnets.cpp ) set(NS3_SRC src/surf/network_ns3.cpp src/surf/ns3/my-point-to-point-helper.cc src/surf/ns3/ns3_interface.cc src/surf/ns3/ns3_simulator.cc src/surf/ns3/red-queue.cc ) set(SURF_SRC src/surf/cpu_cas01.cpp src/surf/cpu_interface.cpp src/surf/cpu_ti.cpp src/surf/fair_bottleneck.cpp src/surf/instr_routing.c src/surf/instr_surf.c src/surf/lagrange.cpp src/surf/maxmin.cpp src/surf/network_cm02.cpp src/surf/network_constant.cpp src/surf/network_interface.cpp src/surf/network_smpi.cpp src/surf/platf_generator.c src/surf/plugins/energy.cpp src/surf/random_mgr.c src/surf/sg_platf.c src/surf/storage_interface.cpp src/surf/storage_n11.cpp src/surf/surf_c_bindings.cpp src/surf/surf_interface.cpp src/surf/surf_routing.cpp src/surf/surf_routing_cluster.cpp src/surf/surf_routing_cluster_fat_tree.cpp src/surf/surf_routing_cluster_torus.cpp src/surf/surf_routing_dijkstra.cpp src/surf/surf_routing_floyd.cpp src/surf/surf_routing_full.cpp src/surf/surf_routing_generic.cpp src/surf/surf_routing_none.cpp src/surf/surf_routing_vivaldi.cpp src/surf/surfxml_parse.c src/surf/surfxml_parseplatf.c src/surf/trace_mgr.c src/surf/vm_workstation_hl13.cpp src/surf/vm_workstation_interface.cpp src/surf/workstation_clm03.cpp src/surf/workstation_interface.cpp src/surf/workstation_ptask_L07.cpp src/xbt/xbt_sg_stubs.c ) set(SIMIX_SRC src/simix/smx_context.c src/simix/smx_context_base.c src/simix/smx_context_raw.c src/simix/smx_deployment.c src/simix/smx_environment.c src/simix/smx_global.c src/simix/smx_host.c src/simix/smx_io.c src/simix/smx_network.c src/simix/smx_process.c src/simix/smx_smurf.c src/simix/smx_synchro.c src/simix/smx_user.c src/simix/smx_vm.c ) set(SIMGRID_SRC src/simgrid/sg_config.c ) set(MSG_SRC src/msg/instr_msg_process.c src/msg/instr_msg_task.c src/msg/instr_msg_vm.c src/msg/msg_actions.c src/msg/msg_deployment.c src/msg/msg_environment.c src/msg/msg_global.c src/msg/msg_gos.c src/msg/msg_host.c src/msg/msg_io.c src/msg/msg_mailbox.c src/msg/msg_process.c src/msg/msg_synchro.c src/msg/msg_task.c src/msg/msg_vm.c ) #* ****************************************************************************************** *# #* TUTORIAL: New API *# set(MSG_SRC ${MSG_SRC} src/msg/msg_new_api.c ) set(EXTRA_DIST ${EXTRA_DIST} src/simix/smx_new_api_private.h ) set(SIMIX_SRC ${SIMIX_SRC} src/simix/smx_new_api.c ) #* ****************************************************************************************** *# set(SIMDAG_SRC src/simdag/instr_sd_task.c src/simdag/sd_daxloader.c src/simdag/sd_global.c src/simdag/sd_link.c src/simdag/sd_task.c src/simdag/sd_workstation.c ) if(HAVE_GRAPHVIZ) set(SIMDAG_SRC ${SIMDAG_SRC} src/simdag/sd_dotloader.c ) else() set(EXTRA_DIST ${EXTRA_DIST} src/simdag/sd_dotloader.c ) endif() set(BINDINGS_SRC src/bindings/bindings_global.c src/bindings/lua/lua_private.h src/bindings/lua/lua_state_cloner.h src/bindings/lua/lua_utils.h src/bindings/lua/simgrid_lua.h ) set(JSURF_SWIG_SRC src/bindings/java/surf.i ) set(JSURF_SWIG_SRC_EXTRA src/bindings/java/surfdoc.i ) set(JSURF_JAVA_C_SRC src/bindings/java/surf_swig.cpp src/bindings/java/surf_swig.hpp ) set(JSURF_JAVA_GENERATED_SRC src/bindings/java/org/simgrid/surf/Action.java src/bindings/java/org/simgrid/surf/ActionList.java src/bindings/java/org/simgrid/surf/ActionState.java src/bindings/java/org/simgrid/surf/Cpu.java src/bindings/java/org/simgrid/surf/CpuAction.java src/bindings/java/org/simgrid/surf/CpuModel.java src/bindings/java/org/simgrid/surf/LmmConstraint.java src/bindings/java/org/simgrid/surf/LmmVariable.java src/bindings/java/org/simgrid/surf/Model.java src/bindings/java/org/simgrid/surf/NetworkAction.java src/bindings/java/org/simgrid/surf/NetworkLink.java src/bindings/java/org/simgrid/surf/Plugin.java src/bindings/java/org/simgrid/surf/Resource.java src/bindings/java/org/simgrid/surf/ResourceState.java src/bindings/java/org/simgrid/surf/RoutingEdge.java src/bindings/java/org/simgrid/surf/Surf.java src/bindings/java/org/simgrid/surf/SurfJNI.java src/bindings/java/org/simgrid/surf/TmgrTrace.java src/bindings/java/org/simgrid/surf/TmgrTraceEvent.java src/bindings/java/org/simgrid/surf/XbtDict.java ) set(JMSG_C_SRC src/bindings/java/jmsg.c src/bindings/java/jmsg.h src/bindings/java/jmsg_as.c src/bindings/java/jmsg_as.h src/bindings/java/jmsg_comm.c src/bindings/java/jmsg_comm.h src/bindings/java/jmsg_file.c src/bindings/java/jmsg_file.h src/bindings/java/jmsg_host.c src/bindings/java/jmsg_host.h src/bindings/java/jmsg_process.c src/bindings/java/jmsg_process.h src/bindings/java/jmsg_rngstream.c src/bindings/java/jmsg_rngstream.h src/bindings/java/jmsg_synchro.c src/bindings/java/jmsg_synchro.h src/bindings/java/jmsg_task.c src/bindings/java/jmsg_task.h src/bindings/java/jmsg_vm.c src/bindings/java/jmsg_vm.h src/bindings/java/jxbt_utilities.c src/bindings/java/jxbt_utilities.h src/bindings/java/smx_context_cojava.c src/bindings/java/smx_context_cojava.h src/bindings/java/smx_context_java.c src/bindings/java/smx_context_java.h ) set(JSURF_C_SRC src/bindings/java/surfJAVA_wrap.cxx src/bindings/java/surfJAVA_wrap.h ${JSURF_JAVA_C_SRC} ) set(JMSG_JAVA_SRC src/bindings/java/org/simgrid/NativeLib.java src/bindings/java/org/simgrid/msg/As.java src/bindings/java/org/simgrid/msg/Comm.java src/bindings/java/org/simgrid/msg/File.java src/bindings/java/org/simgrid/msg/Host.java src/bindings/java/org/simgrid/msg/HostFailureException.java src/bindings/java/org/simgrid/msg/HostNotFoundException.java src/bindings/java/org/simgrid/msg/JniException.java src/bindings/java/org/simgrid/msg/Msg.java src/bindings/java/org/simgrid/msg/MsgException.java src/bindings/java/org/simgrid/msg/Mutex.java src/bindings/java/org/simgrid/msg/NativeException.java src/bindings/java/org/simgrid/msg/Process.java src/bindings/java/org/simgrid/msg/ProcessKilledError.java src/bindings/java/org/simgrid/msg/ProcessNotFoundException.java src/bindings/java/org/simgrid/msg/RngStream.java src/bindings/java/org/simgrid/msg/Semaphore.java src/bindings/java/org/simgrid/msg/Task.java src/bindings/java/org/simgrid/msg/TaskCancelledException.java src/bindings/java/org/simgrid/msg/TimeoutException.java src/bindings/java/org/simgrid/msg/TransferFailureException.java src/bindings/java/org/simgrid/msg/VM.java ${JSURF_JAVA_GENERATED_SRC} ) set(JTRACE_C_SRC src/bindings/java/jtrace.c src/bindings/java/jtrace.h ) set(JTRACE_JAVA_SRC src/bindings/java/org/simgrid/trace/Trace.java ) if(HAVE_TRACING) list(APPEND JMSG_C_SRC ${JTRACE_C_SRC}) list(APPEND JMSG_JAVA_SRC ${JTRACE_JAVA_SRC}) else() list(APPEND EXTRA_DIST ${JTRACE_C_SRC}) list(APPEND EXTRA_DIST ${JTRACE_JAVA_SRC}) endif() set(LUA_SRC src/bindings/lua/lua_comm.c src/bindings/lua/lua_host.c src/bindings/lua/lua_platf.c src/bindings/lua/lua_process.c src/bindings/lua/lua_state_cloner.c src/bindings/lua/lua_task.c src/bindings/lua/lua_utils.c src/bindings/lua/simgrid_lua.c ) set(TRACING_SRC src/instr/instr_TI_trace.c src/instr/instr_config.c src/instr/instr_interface.c src/instr/instr_paje_containers.c src/instr/instr_paje_header.c src/instr/instr_paje_trace.c src/instr/instr_paje_types.c src/instr/instr_paje_values.c src/instr/instr_private.h src/instr/instr_resource_utilization.c src/instr/instr_trace.c ) set(JEDULE_SRC include/instr/jedule/jedule_events.h include/instr/jedule/jedule_output.h include/instr/jedule/jedule_platform.h include/instr/jedule/jedule_sd_binding.h src/instr/jedule/jedule_events.c src/instr/jedule/jedule_output.c src/instr/jedule/jedule_platform.c src/instr/jedule/jedule_sd_binding.c ) set(MC_SRC src/mc/mc_checkpoint.c src/mc/mc_compare.c src/mc/mc_dpor.c src/mc/mc_dwarf.c src/mc/mc_dwarf_attrnames.h src/mc/mc_dwarf_expression.c src/mc/mc_dwarf_tagnames.h src/mc/mc_global.c src/mc/mc_hash.c src/mc/mc_liveness.c src/mc/mc_member.c src/mc/mc_memory.c src/mc/mc_pair.c src/mc/mc_private.h src/mc/mc_request.c src/mc/mc_set.cpp src/mc/mc_state.c src/mc/memory_map.c ) set(headers_to_install include/instr/instr.h include/msg/datatypes.h include/msg/msg.h include/simdag/datatypes.h include/simdag/simdag.h include/simgrid.h include/simgrid/datatypes.h include/simgrid/modelchecker.h include/simgrid/platf.h include/simgrid/platf_generator.h include/simgrid/plugins.h include/simgrid/simix.h include/smpi/mpi.h include/smpi/smpi.h include/smpi/smpi_cocci.h include/smpi/smpi_main.h include/surf/simgrid_dtd.h include/surf/surf_routing.h include/surf/surfxml_parse.h include/xbt.h include/xbt/RngStream.h include/xbt/asserts.h include/xbt/automaton.h include/xbt/config.h include/xbt/cunit.h include/xbt/dict.h include/xbt/dynar.h include/xbt/ex.h include/xbt/fifo.h include/xbt/function_types.h include/xbt/graph.h include/xbt/graphxml.h include/xbt/graphxml_parse.h include/xbt/hash.h include/xbt/heap.h include/xbt/lib.h include/xbt/log.h include/xbt/mallocator.h include/xbt/matrix.h include/xbt/misc.h include/xbt/mmalloc.h include/xbt/module.h include/xbt/parmap.h include/xbt/peer.h include/xbt/queue.h include/xbt/replay.h include/xbt/set.h include/xbt/setset.h include/xbt/str.h include/xbt/strbuff.h include/xbt/swag.h include/xbt/synchro_core.h include/xbt/sysdep.h include/xbt/virtu.h include/xbt/xbt_os_thread.h include/xbt/xbt_os_time.h ) set(source_of_generated_headers include/simgrid_config.h.in include/smpi/mpif.h.in include/smpi/smpif.h.in src/context_sysv_config.h.in) ### depend of some variables setted upper # -->CONTEXT_THREADS CONTEXT_UCONTEXT if(${CONTEXT_THREADS}) #pthread set(SURF_SRC ${SURF_SRC} src/simix/smx_context_thread.c src/xbt/xbt_os_thread.c ) else() # NOT pthread set(EXTRA_DIST ${EXTRA_DIST} src/simix/smx_context_thread.c src/xbt/xbt_os_thread.c ) endif() if(${CONTEXT_UCONTEXT}) #ucontext set(SURF_SRC ${SURF_SRC} src/simix/smx_context_sysv.c ) else() # NOT ucontext set(EXTRA_DIST ${EXTRA_DIST} src/simix/smx_context_sysv.c ) endif() # -->HAVE_GTNETS if(HAVE_GTNETS) set(GTNETS_USED ${GTNETS_SRC} ) else() set(GTNETS_USED "") set(EXTRA_DIST ${EXTRA_DIST} ${GTNETS_SRC} ) endif() ### Simgrid Lib sources set(simgrid_sources ${BINDINGS_SRC} ${GTNETS_USED} ${MSG_SRC} ${SIMDAG_SRC} ${SIMGRID_SRC} ${SIMIX_SRC} ${SURF_SRC} ${XBT_SRC} ) if(${HAVE_JEDULE}) set(simgrid_sources ${simgrid_sources} ${JEDULE_SRC} ) else() set(EXTRA_DIST ${EXTRA_DIST} ${JEDULE_SRC} ) endif() if(enable_smpi) set(simgrid_sources ${simgrid_sources} ${SMPI_SRC} ) endif() if(${HAVE_TRACING}) set(simgrid_sources ${simgrid_sources} ${TRACING_SRC} ) else() set(EXTRA_DIST ${EXTRA_DIST} ${TRACING_SRC} ) endif() if(HAVE_MC) set(simgrid_sources ${simgrid_sources} ${MC_SRC} ) endif() if(HAVE_NS3) set(simgrid_sources ${simgrid_sources} ${NS3_SRC} ) endif() # WINDOWS if(WIN32) set(simgrid_sources ${simgrid_sources} src/simix/smx_context_thread.c src/xbt/win32_ucontext.c src/xbt/xbt_os_thread.c ) endif() if(${HAVE_LUA}) set(simgrid_sources ${simgrid_sources} ${LUA_SRC} ) else() set(EXTRA_DIST ${EXTRA_DIST} ${LUA_SRC} ) endif() set(DOC_SOURCES doc/Doxyfile.in doc/Layout.xml doc/sg_thread_model.fig doc/simix.fig doc/surf_nutshell.fig doc/surf++.png doc/surf++.pdf doc/surf++.graphml doc/surf++.uml doc/triva-graph_configuration.png doc/triva-graph_configuration.svg doc/triva-graph_visualization.png doc/triva-graph_visualization.svg doc/triva-time_interval.png doc/triva-time_interval.svg doc/HelloWorld/CMakeLists.txt doc/HelloWorld/HelloWorld.c doc/HelloWorld/README doc/doxygen/FAQ.doc doc/doxygen/advanced.doc doc/doxygen/bindings.doc doc/doxygen/contributing.doc doc/doxygen/deployment.doc doc/doxygen/footer.html doc/doxygen/getting_started.doc doc/doxygen/header.html doc/doxygen/help.doc doc/doxygen/index.doc doc/doxygen/inside_autotests.doc doc/doxygen/inside_cmake.doc doc/doxygen/inside_doxygen.doc doc/doxygen/inside_extending.doc doc/doxygen/inside_release.doc doc/doxygen/install.doc doc/doxygen/internals.doc doc/doxygen/introduction.doc doc/doxygen/module-msg.doc doc/doxygen/module-sd.doc doc/doxygen/module-simix.doc doc/doxygen/module-smpi.doc doc/doxygen/module-surf.doc doc/doxygen/module-trace.doc doc/doxygen/module-xbt.doc doc/doxygen/modules.doc doc/doxygen/options.doc doc/doxygen/platform.doc doc/doxygen/pls.doc doc/doxygen/stylesheet.css doc/doxygen/tracing.doc doc/doxygen/use.doc doc/manpage/smpicc.1 doc/manpage/smpirun.1 doc/msg-tuto-src/deployment0.xml doc/msg-tuto-src/deployment1.xml doc/msg-tuto-src/deployment2.xml doc/msg-tuto-src/deployment3.xml doc/msg-tuto-src/deployment_general.xml doc/msg-tuto-src/masterworker0.c doc/msg-tuto-src/masterworker1.c doc/msg-tuto-src/masterworker2.c doc/msg-tuto-src/masterworker3.c doc/msg-tuto-src/masterworker4.c doc/msg-tuto-src/platforms/cloud.xml doc/msg-tuto-src/platforms/g5k.xml doc/msg-tuto-src/platforms/griffon.xml doc/msg-tuto-src/platforms/peers.xml doc/msg-tuto-src/platforms/platform.xml CITATION.bib ) set(DOC_FIGS ${CMAKE_HOME_DIRECTORY}/doc/shared/fig/simgrid_modules.fig ${CMAKE_HOME_DIRECTORY}/doc/shared/fig/simgrid_modules2.fig ) set(DOC_TOOLS tools/doxygen/fig2dev_postprocessor.pl tools/doxygen/index_create.pl tools/doxygen/xbt_log_extract_hierarchy.pl ) # these files get copied automatically to the html documentation set(DOC_IMG ${CMAKE_HOME_DIRECTORY}/doc/simgrid.css ${CMAKE_HOME_DIRECTORY}/doc/sc3-description.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/AS_hierarchy.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/Paje_MSG_screenshot.jpg ${CMAKE_HOME_DIRECTORY}/doc/webcruft/Paje_MSG_screenshot_thn.jpg ${CMAKE_HOME_DIRECTORY}/doc/webcruft/SGicon.gif ${CMAKE_HOME_DIRECTORY}/doc/webcruft/SGicon.icns ${CMAKE_HOME_DIRECTORY}/doc/webcruft/SGicon.ico ${CMAKE_HOME_DIRECTORY}/doc/webcruft/awstats_logo3.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/output.goal.pdf ${CMAKE_HOME_DIRECTORY}/doc/webcruft/poster_thumbnail.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/simgrid_logo_2011.gif ${CMAKE_HOME_DIRECTORY}/doc/webcruft/simgrid_logo_2011.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/simgrid_logo_2011_small.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/simgrid_logo_win.bmp ${CMAKE_HOME_DIRECTORY}/doc/webcruft/simgrid_logo_win_2011.bmp ${CMAKE_HOME_DIRECTORY}/doc/webcruft/win_install_01.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/win_install_02.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/win_install_03.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/win_install_04.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/win_install_05.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/win_install_06.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/smpi_simgrid_alltoall_pair_16.png ${CMAKE_HOME_DIRECTORY}/doc/webcruft/smpi_simgrid_alltoall_ring_16.png ) set(bin_files ${bin_files} src/smpi/smpicc.in src/smpi/smpicxx.in src/smpi/smpif2c.in src/smpi/smpiff.in src/smpi/smpif90.in src/smpi/smpirun.in src/smpi/smpitools.sh ) set(txt_files ${txt_files} AUTHORS COPYING README README.java ChangeLog ChangeLog.SimGrid-java INSTALL LICENSE-LGPL-2.1 NEWS TODO configure ) set(EXAMPLES_CMAKEFILES_TXT examples/java/CMakeLists.txt examples/java/async/CMakeLists.txt examples/java/bittorrent/CMakeLists.txt examples/java/chord/CMakeLists.txt examples/java/cloud/CMakeLists.txt examples/java/cloud/migration/CMakeLists.txt examples/java/commTime/CMakeLists.txt examples/java/io/CMakeLists.txt examples/java/kademlia/CMakeLists.txt examples/java/master_slave_bypass/CMakeLists.txt examples/java/master_slave_kill/CMakeLists.txt examples/java/masterslave/CMakeLists.txt examples/java/migration/CMakeLists.txt examples/java/mutualExclusion/CMakeLists.txt examples/java/pingPong/CMakeLists.txt examples/java/priority/CMakeLists.txt examples/java/reservationSurfPlugin/CMakeLists.txt examples/java/startKillTime/CMakeLists.txt examples/java/surfCpuModel/CMakeLists.txt examples/java/surfPlugin/CMakeLists.txt examples/java/suspend/CMakeLists.txt examples/java/tracing/CMakeLists.txt examples/lua/CMakeLists.txt examples/msg/CMakeLists.txt examples/msg/actions/CMakeLists.txt examples/msg/bittorrent/CMakeLists.txt examples/msg/chainsend/CMakeLists.txt examples/msg/chord/CMakeLists.txt examples/msg/cloud/CMakeLists.txt examples/msg/energy/e1/CMakeLists.txt examples/msg/energy/e2/CMakeLists.txt examples/msg/energy/e3/CMakeLists.txt examples/msg/gpu/CMakeLists.txt examples/msg/gtnets/CMakeLists.txt examples/msg/icomms/CMakeLists.txt examples/msg/io/CMakeLists.txt examples/msg/kademlia/CMakeLists.txt examples/msg/masterslave/CMakeLists.txt examples/msg/mc/CMakeLists.txt examples/msg/migration/CMakeLists.txt examples/msg/ns3/CMakeLists.txt examples/msg/parallel_task/CMakeLists.txt examples/msg/pastry/CMakeLists.txt examples/msg/pmm/CMakeLists.txt examples/msg/priority/CMakeLists.txt examples/msg/properties/CMakeLists.txt examples/msg/semaphores/CMakeLists.txt examples/msg/sendrecv/CMakeLists.txt examples/msg/start_kill_time/CMakeLists.txt examples/msg/suspend/CMakeLists.txt examples/msg/token_ring/CMakeLists.txt examples/msg/tracing/CMakeLists.txt examples/scala/CMakeLists.txt examples/scala/master_slave_bypass/CMakeLists.txt examples/scala/master_slave_kill/CMakeLists.txt examples/scala/masterslave/CMakeLists.txt examples/simdag/CMakeLists.txt examples/simdag/dax/CMakeLists.txt examples/simdag/dot/CMakeLists.txt examples/simdag/goal/CMakeLists.txt examples/simdag/io/CMakeLists.txt examples/simdag/metaxml/CMakeLists.txt examples/simdag/properties/CMakeLists.txt examples/simdag/scheduling/CMakeLists.txt examples/smpi/CMakeLists.txt examples/smpi/smpi_msg_masterslave/CMakeLists.txt examples/smpi/MM/CMakeLists.txt examples/smpi/energy/CMakeLists.txt examples/smpi/energy/f77/CMakeLists.txt examples/smpi/energy/f90/CMakeLists.txt examples/xbt/CMakeLists.txt ) set(TESHSUITE_CMAKEFILES_TXT teshsuite/bug-17132/CMakeLists.txt teshsuite/mc/dwarf/CMakeLists.txt teshsuite/mc/dwarf_expression/CMakeLists.txt teshsuite/msg/CMakeLists.txt teshsuite/msg/get_sender/CMakeLists.txt teshsuite/msg/host_on_off/CMakeLists.txt teshsuite/msg/pid/CMakeLists.txt teshsuite/msg/process/CMakeLists.txt teshsuite/msg/process_join/CMakeLists.txt teshsuite/msg/storage/CMakeLists.txt teshsuite/msg/task_destroy_cancel/CMakeLists.txt teshsuite/msg/trace/CMakeLists.txt teshsuite/simdag/availability/CMakeLists.txt teshsuite/simdag/basic/CMakeLists.txt teshsuite/simdag/incomplete/CMakeLists.txt teshsuite/simdag/network/CMakeLists.txt teshsuite/simdag/network/mxn/CMakeLists.txt teshsuite/simdag/network/p2p/CMakeLists.txt teshsuite/simdag/partask/CMakeLists.txt teshsuite/simdag/platforms/CMakeLists.txt teshsuite/simix/check_defaults/CMakeLists.txt teshsuite/simix/stack_overflow/CMakeLists.txt teshsuite/smpi/CMakeLists.txt teshsuite/smpi/allgather/CMakeLists.txt teshsuite/smpi/allgatherv/CMakeLists.txt teshsuite/smpi/allreduce/CMakeLists.txt teshsuite/smpi/alltoall/CMakeLists.txt teshsuite/smpi/alltoallv/CMakeLists.txt teshsuite/smpi/barrier/CMakeLists.txt teshsuite/smpi/bcast/CMakeLists.txt teshsuite/smpi/compute/CMakeLists.txt teshsuite/smpi/gather/CMakeLists.txt teshsuite/smpi/hvector/CMakeLists.txt teshsuite/smpi/indexed/CMakeLists.txt teshsuite/smpi/pingpong/CMakeLists.txt teshsuite/smpi/reduce/CMakeLists.txt teshsuite/smpi/scatter/CMakeLists.txt teshsuite/smpi/shared/CMakeLists.txt teshsuite/smpi/struct/CMakeLists.txt teshsuite/smpi/vector/CMakeLists.txt teshsuite/smpi/mpich3-test/CMakeLists.txt teshsuite/smpi/mpich3-test/attr/CMakeLists.txt teshsuite/smpi/mpich3-test/coll/CMakeLists.txt teshsuite/smpi/mpich3-test/comm/CMakeLists.txt teshsuite/smpi/mpich3-test/datatype/CMakeLists.txt # teshsuite/smpi/mpich3-test/f77/attr/CMakeLists.txt teshsuite/smpi/mpich3-test/f77/coll/CMakeLists.txt teshsuite/smpi/mpich3-test/f77/comm/CMakeLists.txt teshsuite/smpi/mpich3-test/f77/datatype/CMakeLists.txt teshsuite/smpi/mpich3-test/f77/ext/CMakeLists.txt teshsuite/smpi/mpich3-test/f77/init/CMakeLists.txt teshsuite/smpi/mpich3-test/f77/pt2pt/CMakeLists.txt teshsuite/smpi/mpich3-test/f77/util/CMakeLists.txt teshsuite/smpi/mpich3-test/f90/coll/CMakeLists.txt teshsuite/smpi/mpich3-test/f90/datatype/CMakeLists.txt teshsuite/smpi/mpich3-test/f90/init/CMakeLists.txt teshsuite/smpi/mpich3-test/f90/pt2pt/CMakeLists.txt teshsuite/smpi/mpich3-test/f90/util/CMakeLists.txt teshsuite/smpi/mpich3-test/group/CMakeLists.txt teshsuite/smpi/mpich3-test/init/CMakeLists.txt teshsuite/smpi/mpich3-test/pt2pt/CMakeLists.txt teshsuite/smpi/mpich3-test/topo/CMakeLists.txt teshsuite/surf/CMakeLists.txt teshsuite/surf/lmm_usage/CMakeLists.txt teshsuite/surf/maxmin_bench/CMakeLists.txt teshsuite/surf/surf_usage/CMakeLists.txt teshsuite/surf/trace_usage/CMakeLists.txt teshsuite/xbt/graphxml_usage/CMakeLists.txt teshsuite/xbt/heap_bench/CMakeLists.txt teshsuite/xbt/log_large/CMakeLists.txt teshsuite/xbt/log_usage/CMakeLists.txt teshsuite/xbt/mmalloc/CMakeLists.txt teshsuite/xbt/parallel_log/CMakeLists.txt teshsuite/xbt/parmap_bench/CMakeLists.txt teshsuite/xbt/parmap_test/CMakeLists.txt ) set(TOOLS_CMAKEFILES_TXT tools/CMakeLists.txt tools/graphicator/CMakeLists.txt tools/tesh/CMakeLists.txt ) set(CMAKE_SOURCE_FILES CMakeLists.txt buildtools/Cmake/AddTests.cmake buildtools/Cmake/CTestConfig.cmake buildtools/Cmake/CTestCustom.cmake buildtools/Cmake/CompleteInFiles.cmake buildtools/Cmake/DefinePackages.cmake buildtools/Cmake/Distrib.cmake buildtools/Cmake/Flags.cmake buildtools/Cmake/GenerateDoc.cmake buildtools/Cmake/GenerateDocWin.cmake buildtools/Cmake/MaintainerMode.cmake buildtools/Cmake/MakeExe.cmake buildtools/Cmake/MakeJava.cmake buildtools/Cmake/MakeLib.cmake buildtools/Cmake/MakeLibWin.cmake buildtools/Cmake/Modules/FindF2c.cmake buildtools/Cmake/Modules/FindGFortran.cmake buildtools/Cmake/Modules/FindGTnets.cmake buildtools/Cmake/Modules/FindGraphviz.cmake buildtools/Cmake/Modules/FindLibSigc++.cmake buildtools/Cmake/Modules/FindLibdw.cmake buildtools/Cmake/Modules/FindLibunwind.cmake buildtools/Cmake/Modules/FindLua51Simgrid.cmake buildtools/Cmake/Modules/FindNS3.cmake buildtools/Cmake/Modules/FindRngStream.cmake buildtools/Cmake/Modules/FindRubySimgrid.cmake buildtools/Cmake/Modules/FindScala.cmake buildtools/Cmake/Modules/FindSimGrid.cmake buildtools/Cmake/Modules/FindValgrind.cmake buildtools/Cmake/Option.cmake buildtools/Cmake/Pipol.cmake buildtools/Cmake/PrintArgs.cmake buildtools/Cmake/Scripts/Diff.pm buildtools/Cmake/Scripts/Makefile.default buildtools/Cmake/Scripts/SimGrid.packproj buildtools/Cmake/Scripts/generate_memcheck_tests.pl buildtools/Cmake/Scripts/java_bundle.sh buildtools/Cmake/Scripts/my_valgrind.pl buildtools/Cmake/Scripts/postinstall.sh buildtools/Cmake/Scripts/preinstall.sh buildtools/Cmake/Scripts/tesh.pl buildtools/Cmake/Scripts/update_tesh.pl buildtools/Cmake/UnitTesting.cmake buildtools/Cmake/src/internal_config.h.in buildtools/Cmake/src/simgrid.nsi.in buildtools/Cmake/test_prog/prog_AC_CHECK_MCSC.c buildtools/Cmake/test_prog/prog_gnu_dynlinker.c buildtools/Cmake/test_prog/prog_gtnets.cpp buildtools/Cmake/test_prog/prog_mutex_timedlock.c buildtools/Cmake/test_prog/prog_printf_null.c buildtools/Cmake/test_prog/prog_sem_init.c buildtools/Cmake/test_prog/prog_sem_open.c buildtools/Cmake/test_prog/prog_sem_timedwait.c buildtools/Cmake/test_prog/prog_snprintf.c buildtools/Cmake/test_prog/prog_stackgrowth.c buildtools/Cmake/test_prog/prog_stacksetup.c buildtools/Cmake/test_prog/prog_thread_storage.c buildtools/Cmake/test_prog/prog_vsnprintf.c ) set(PLATFORMS_EXAMPLES examples/platforms/bypassASroute.xml examples/platforms/bypassRoute.xml examples/platforms/cloud.xml examples/platforms/cluster.xml examples/platforms/cluster_and_one_host.xml examples/platforms/cluster_no_backbone.xml examples/platforms/clusters_routing_full.xml examples/platforms/conf/gridpp_grid_2004.conf examples/platforms/conf/gridpp_grid_2004.xml examples/platforms/conf/lcg_sept2004_grid.conf examples/platforms/conf/lcg_sept2004_grid.xml examples/platforms/conf/transform_optorsim_platform.pl examples/platforms/config.xml examples/platforms/content/small_content.txt examples/platforms/content/storage_content.txt examples/platforms/content/win_storage_content.txt examples/platforms/data_center.xml examples/platforms/deployment_remote_io.xml examples/platforms/fat_tree_cluster.xml examples/platforms/g5k.xml examples/platforms/generation_scripts/create_hierarchical_clusters.pl examples/platforms/generation_scripts/enhancedDTDwithHierarchicalCluster.pl examples/platforms/generation_scripts/generate_g5k_platform.pl examples/platforms/generation_scripts/generate_g5k_platform_cabinets.pl examples/platforms/griffon.xml examples/platforms/meta_cluster.xml examples/platforms/multicore_machine.xml examples/platforms/prop.xml examples/platforms/remote_io.xml examples/platforms/routing_cluster.xml examples/platforms/storage.xml examples/platforms/syscoord/generate_peer_platform.pl examples/platforms/syscoord/median_harvard.syscoord examples/platforms/syscoord/median_harvard.xml examples/platforms/syscoord/median_meridian.syscoord examples/platforms/syscoord/median_meridian.xml examples/platforms/syscoord/median_p2psim.syscoord examples/platforms/syscoord/median_p2psim.xml examples/platforms/torus_cluster.xml examples/platforms/two_peers.xml examples/platforms/vivaldi.xml ) set(generated_src_files src/xbt/automaton/automaton_lexer.yy.c src/xbt/automaton/parserPromela.tab.cacc src/xbt/automaton/parserPromela.tab.hacc ) foreach(file ${generated_src_files}) set_source_files_properties(${file} PROPERTIES GENERATED true) endforeach(file ${generated_src_files}) SimGrid-3.11/buildtools/Cmake/MakeLib.cmake000644 001750 001750 00000012203 12342443653 017536 0ustar00cici000000 000000 ### Make Libs ############################### # Declare the library content # ############################### # Actually declare our libraries add_library(simgrid SHARED ${simgrid_sources}) set_target_properties(simgrid PROPERTIES VERSION ${libsimgrid_version}) if(enable_lib_static) add_library(simgrid_static STATIC ${simgrid_sources}) endif() if(enable_java) include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/MakeJava.cmake) endif() add_dependencies(simgrid maintainer_files) # Compute the dependencies of SimGrid ##################################### set(SIMGRID_DEP "-lm") if(${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD" AND NOT ${CMAKE_SYSTEM_VERSION} VERSION_LESS 10.0 AND ${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang") # FreeBSD from 10.0 provide a internal C++ stack (unused by gcc) set(SIMGRID_DEP "${SIMGRID_DEP} -lc++") else() set(SIMGRID_DEP "${SIMGRID_DEP} -lstdc++") endif() if(pthread) if(${CONTEXT_THREADS}) SET(SIMGRID_DEP "${SIMGRID_DEP} -pthread") endif() endif() if(HAVE_LUA) ADD_CUSTOM_TARGET(link_simgrid_lua ALL DEPENDS simgrid ${CMAKE_BINARY_DIR}/examples/lua/simgrid.${LIB_EXE} ${CMAKE_BINARY_DIR}/examples/msg/masterslave/simgrid.${LIB_EXE} ${CMAKE_BINARY_DIR}/examples/simdag/simgrid.${LIB_EXE} ) add_custom_command( OUTPUT ${CMAKE_BINARY_DIR}/examples/lua/simgrid.${LIB_EXE} ${CMAKE_BINARY_DIR}/examples/msg/masterslave/simgrid.${LIB_EXE} ${CMAKE_BINARY_DIR}/examples/simdag/simgrid.${LIB_EXE} COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_BINARY_DIR}/examples/lua/simgrid.${LIB_EXE} # if it exists, creating the link fails. So cleanup before hand COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/examples/lua/ COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_BINARY_DIR}/lib/libsimgrid.${LIB_EXE} ${CMAKE_BINARY_DIR}/examples/lua/simgrid.${LIB_EXE} #for test COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_BINARY_DIR}/examples/msg/masterslave/simgrid.${LIB_EXE} # if it exists, creating the link fails. So cleanup before hand COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/examples/msg/masterslave/ COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_BINARY_DIR}/lib/libsimgrid.${LIB_EXE} ${CMAKE_BINARY_DIR}/examples/msg/masterslave/simgrid.${LIB_EXE} #for test COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_BINARY_DIR}/examples/simdag/simgrid.${LIB_EXE} # if it exists, creating the link fails. So cleanup before hand COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/examples/simdag/ COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_BINARY_DIR}/lib/libsimgrid.${LIB_EXE} ${CMAKE_BINARY_DIR}/examples/simdag/simgrid.${LIB_EXE} #for test ) SET(SIMGRID_DEP "${SIMGRID_DEP} -l${LIB_LUA_NAME}") endif() if(HAVE_GRAPHVIZ) if(HAVE_CGRAPH_LIB) SET(SIMGRID_DEP "${SIMGRID_DEP} -lcgraph") else() if(HAVE_AGRAPH_LIB) SET(SIMGRID_DEP "${SIMGRID_DEP} -lagraph -lcdt") endif() endif() endif() if(HAVE_LIBSIGC++) SET(SIMGRID_DEP "${SIMGRID_DEP} -lsigc-2.0") endif() if(HAVE_GTNETS) SET(SIMGRID_DEP "${SIMGRID_DEP} -lgtnets") endif() if(HAVE_MC) # The availability of libunwind was checked in CompleteInFiles.cmake # (that includes FindLibunwind.cmake), so simply load it now. SET(SIMGRID_DEP "${SIMGRID_DEP} -lunwind") # Same for libdw SET(SIMGRID_DEP "${SIMGRID_DEP} -ldw") # This supposes that the host machine is either an AMD or a X86. # This is deeply wrong, and should be fixed by manually loading -lunwind-PLAT (FIXME) if(PROCESSOR_x86_64) SET(SIMGRID_DEP "${SIMGRID_DEP} -lunwind-x86_64") else() SET(SIMGRID_DEP "${SIMGRID_DEP} -lunwind-x86") endif() endif() if(MMALLOC_WANT_OVERRIDE_LEGACY AND HAVE_GNU_LD) SET(SIMGRID_DEP "${SIMGRID_DEP} ${DL_LIBRARY}") endif() if(HAVE_NS3) if(${NS3_VERSION_MINOR} EQUAL 10) SET(SIMGRID_DEP "${SIMGRID_DEP} -lns3") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_NS3_3_10") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_NS3_3_10") else() SET(SIMGRID_DEP "${SIMGRID_DEP} -lns3.${NS3_VERSION_MINOR}-core -lns3.${NS3_VERSION_MINOR}-csma -lns3.${NS3_VERSION_MINOR}-point-to-point -lns3.${NS3_VERSION_MINOR}-internet -lns3.${NS3_VERSION_MINOR}-applications") endif() endif() if(HAVE_POSIX_GETTIME) SET(SIMGRID_DEP "${SIMGRID_DEP} -lrt") endif() if(HAVE_BACKTRACE_IN_LIBEXECINFO) SET(SIMGRID_DEP "${SIMGRID_DEP} -lexecinfo") endif(HAVE_BACKTRACE_IN_LIBEXECINFO) # Compute the dependencies of SMPI ################################## if(enable_smpi AND APPLE) set(SIMGRID_DEP "${SIMGRID_DEP} -Wl,-U -Wl,_smpi_simulated_main") endif() target_link_libraries(simgrid ${SIMGRID_DEP}) # Pass dependencies to static libs ################################## if(enable_lib_static) target_link_libraries(simgrid_static ${SIMGRID_DEP}) add_dependencies(simgrid_static maintainer_files) set_target_properties(simgrid_static PROPERTIES OUTPUT_NAME simgrid) endif() # Dependencies from maintainer mode ################################### if(enable_maintainer_mode AND PYTHON_EXE) add_dependencies(simgrid simcalls_generated_src) endif() if(enable_maintainer_mode AND BISON_EXE AND LEX_EXE) add_dependencies(simgrid automaton_generated_src) endif() SimGrid-3.11/buildtools/Cmake/Scripts/000755 001750 001750 00000000000 12342443653 016661 5ustar00cici000000 000000 SimGrid-3.11/buildtools/Cmake/Scripts/generate_memcheck_tests.pl000755 001750 001750 00000016202 12342443653 024072 0ustar00cici000000 000000 #!/usr/bin/perl -w # Copyright (c) 2012-2014. The SimGrid Team. # All rights reserved. # This program is free software; you can redistribute it and/or modify it # under the terms of the license (GNU LGPL) which comes with this package. use strict; # input file = AddTest.txt if ( $#ARGV != 1 ) { die "Usage: generate_memcheck_tests.pl AddTests.cmake\n"; } my ($proj_dir) = $ARGV[0]; open MAKETEST, $ARGV[1] or die "Unable to open file: \"$ARGV[1]\". $!\n"; sub var_subst { my ($text, $name, $value) = @_; if ($value) { $text =~ s/\${$name(?::[=-][^}]*)?}/$value/g; $text =~ s/\$$name(\W|$)/$value$1/g; } else { $text =~ s/\${$name:=([^}]*)}/$1/g; $text =~ s/\${$name}//g; $text =~ s/\$$name(\W|$)/$1/g; } return $text; } my (@test_list) = (); my ($nb_test) = 0; my ($line); my ($path); my ($dump) = 0; my (%environ); my ($tesh_file); my ($factories); my ($config_var); my ($name_test); my ($indent); while ( defined( $line = ) ) { chomp $line; if ( $line =~ /BEGIN TESH TESTS/ ) { $dump = 1; next; } if ( $line =~ /END TESH TESTS/ ) { $dump = 0; next; } if ($dump) { $line =~ s/^ //; if ( $line =~ /^\s*(?:ADD_TEST\(\S+\s+\S*TESH\_COMMAND\}\s|ADD_TESH\(|ADD_TESH_FACTORIES)/ ) { undef %environ; $config_var = ""; $factories = ""; $path = ""; $nb_test++; $tesh_file = ""; $name_test = ""; $indent = ""; if ( $line =~ /^(\s*)ADD_(?:TEST|TESH)\((\S+)/ ) { $indent = ($1); $name_test = ($2); } if ( $line =~ /^(\s*)ADD_TESH_FACTORIES\((\S+)\s+\"(\S+)\"/ ) { $indent = ($1); $name_test = ($2); $factories = ($3); } while ( $line =~ /--cfg\s+(\S+)/g ) { $config_var = "--cfg=$1 $config_var"; } while ( $line =~ /--cd\s+(\S+)/g ) { $path = ($1); $path =~ s/\"//g; } while ( $line =~ /--setenv\s+(\S+)\=(\S+)/g ) { my ( $env_var, $value_var ) = ( $1, $2 ); $environ{$env_var} = $value_var; } if ( $line =~ /(\S+)\s*\)$/ ) { $tesh_file = $1; $tesh_file =~ s/^[^\/\$]/$path\/$&/; $tesh_file =~ s/\${CMAKE_HOME_DIRECTORY}/$proj_dir/g; if ( ! -e "$tesh_file" ) { print "# tesh_file: $tesh_file does not exist!\n"; print "# $line\n"; next; } } if (0) { print "test_name = $name_test\n"; print "config_var = $config_var\n"; print "path = $path\n"; foreach my $key (keys %environ) { print "$key = $environ{$key}\n"; } print "tesh_file = $tesh_file\n"; print "\n\n"; } my ($count) = 0; open TESH_FILE, $tesh_file or die "Unable to open tesh file: \"$tesh_file\". $!\n"; my ($input) = ""; my ($l); while ( defined( $l = ) ) { chomp $l; if ( $l =~ /^< (.*)$/ ) { $input = $input . $1 . "\n"; } if ( $l =~ /^\$ (.*)$/ ) { my ($command) = $1; foreach my $key (keys %environ) { $command = var_subst($command, $key, $environ{$key}); } # substitute remaining known variables, if any $command = var_subst($command, "srcdir", ""); $command = var_subst($command, "bindir", ""); $command = var_subst($command, "EXEEXT", ""); $command = var_subst($command, "SG_TEST_EXENV", ""); $command = var_subst($command, "SG_TEST_ENV", ""); $command = var_subst($command, "SG_EXENV_TEST", ""); $command =~ s/\$@//g; # $command =~ s/..\/..\/bin\/smpirun/\${CMAKE_BINARY_DIR\}\/bin\/smpirun/g; $command =~ s/^\s+//; $command =~ s/^[^\/\$]\S*\//$path\/$&/; $command =~ s/^(\S*\/)(?:\.\/)+/$1/g; if ($config_var) { $command = "$command $config_var"; } if ( $command =~ /^mkfile\s+(\S+)/) { my $file = $1; # don't ask me to explain why so many backslashes... $input =~ s/\\/\\\\\\\\/g; $input =~ s/\n/\\\\n/g; $input =~ s/"/\\\\042/g; $input =~ s/'/\\\\047/g; $input =~ s/%/%%/g; $command = "sh -c \"printf '$input' > $file\""; } if ($factories) { foreach my $factory (split(';', $factories)) { print "${indent}ADD_TEST(NAME memcheck-$name_test-$factory-$count\n"; print "${indent} WORKING_DIRECTORY $path\/\n"; print "${indent} COMMAND $command --cfg=contexts/factory:$factory)\n"; if ($count > 0) { print "${indent}set_tests_properties(memcheck-$name_test-$factory-$count\n"; print "${indent} PROPERTIES DEPENDS memcheck-$name_test-$factory-" . ($count - 1) . ")\n"; } } } else { print "${indent}ADD_TEST(NAME memcheck-$name_test-$count\n"; print "${indent} WORKING_DIRECTORY $path\/\n"; print "${indent} COMMAND $command)\n"; if ($count > 0) { print "${indent}set_tests_properties(memcheck-$name_test-$count\n"; print "${indent} PROPERTIES DEPENDS memcheck-$name_test-" . ($count - 1) . ")\n"; } } $input = ""; #push @test_list, "memcheck-$name_test-$count"; $count++; } if ( $l =~ /^\& (.*)$/ ) { last; } } close(TESH_FILE); } elsif ( $line =~ /^\s*SET_TESTS_PROPERTIES/ ) { if ( $line =~ /SET_TESTS_PROPERTIES\(([\S]+)/ ) { my ($name_temp) = ($1); $line =~ s/$name_temp/memcheck-$name_temp-0/g; print $line. "\n"; } } elsif ( $line =~ /^(\s*)ADD_TEST\((.*)\)/ ) { print "$1ADD_TEST(memcheck-$2)\n"; } else { print $line. "\n"; } } } close(MAKETEST); #print "nb_test = $nb_test\n"; #print "set(MEMCHECK_LIST\n"; #print (join("\n", @test_list)); #print ")\n"; SimGrid-3.11/buildtools/Cmake/Scripts/preinstall.sh000755 001750 001750 00000000075 12342443653 021377 0ustar00cici000000 000000 #! /bin/bash echo "\n#SIMGRID ICEBERG" >> ~/.profile return 0SimGrid-3.11/buildtools/Cmake/Scripts/Diff.pm000644 001750 001750 00000143575 12342443653 020106 0ustar00cici000000 000000 package Diff; # Skip to first "=head" line for documentation. use strict; use integer; # see below in _replaceNextLargerWith() for mod to make # if you don't use this use vars qw( $VERSION @EXPORT_OK ); $VERSION = 1.19_02; # ^ ^^ ^^-- Incremented at will # | \+----- Incremented for non-trivial changes to features # \-------- Incremented for fundamental changes require Exporter; *import = \&Exporter::import; @EXPORT_OK = qw( prepare LCS LCSidx LCS_length diff sdiff compact_diff traverse_sequences traverse_balanced ); # McIlroy-Hunt diff algorithm # Adapted from the Smalltalk code of Mario I. Wolczko, # by Ned Konz, perl@bike-nomad.com # Updates by Tye McQueen, http://perlmonks.org/?node=tye # Create a hash that maps each element of $aCollection to the set of # positions it occupies in $aCollection, restricted to the elements # within the range of indexes specified by $start and $end. # The fourth parameter is a subroutine reference that will be called to # generate a string to use as a key. # Additional parameters, if any, will be passed to this subroutine. # # my $hashRef = _withPositionsOfInInterval( \@array, $start, $end, $keyGen ); sub _withPositionsOfInInterval { my $aCollection = shift; # array ref my $start = shift; my $end = shift; my $keyGen = shift; my %d; my $index; for ( $index = $start ; $index <= $end ; $index++ ) { my $element = $aCollection->[$index]; my $key = &$keyGen( $element, @_ ); if ( exists( $d{$key} ) ) { unshift ( @{ $d{$key} }, $index ); } else { $d{$key} = [$index]; } } return wantarray ? %d : \%d; } # Find the place at which aValue would normally be inserted into the # array. If that place is already occupied by aValue, do nothing, and # return undef. If the place does not exist (i.e., it is off the end of # the array), add it to the end, otherwise replace the element at that # point with aValue. It is assumed that the array's values are numeric. # This is where the bulk (75%) of the time is spent in this module, so # try to make it fast! sub _replaceNextLargerWith { my ( $array, $aValue, $high ) = @_; $high ||= $#$array; # off the end? if ( $high == -1 || $aValue > $array->[-1] ) { push ( @$array, $aValue ); return $high + 1; } # binary search for insertion point... my $low = 0; my $index; my $found; while ( $low <= $high ) { $index = ( $high + $low ) / 2; # $index = int(( $high + $low ) / 2); # without 'use integer' $found = $array->[$index]; if ( $aValue == $found ) { return undef; } elsif ( $aValue > $found ) { $low = $index + 1; } else { $high = $index - 1; } } # now insertion point is in $low. $array->[$low] = $aValue; # overwrite next larger return $low; } # This method computes the longest common subsequence in $a and $b. # Result is array or ref, whose contents is such that # $a->[ $i ] == $b->[ $result[ $i ] ] # foreach $i in ( 0 .. $#result ) if $result[ $i ] is defined. # An additional argument may be passed; this is a hash or key generating # function that should return a string that uniquely identifies the given # element. It should be the case that if the key is the same, the elements # will compare the same. If this parameter is undef or missing, the key # will be the element as a string. # By default, comparisons will use "eq" and elements will be turned into keys # using the default stringizing operator '""'. # Additional parameters, if any, will be passed to the key generation # routine. sub _longestCommonSubsequence { my $a = shift; # array ref or hash ref my $b = shift; # array ref or hash ref my $counting = shift; # scalar my $keyGen = shift; # code ref my $compare; # code ref if ( ref($a) eq 'HASH' ) { # prepared hash must be in $b my $tmp = $b; $b = $a; $a = $tmp; } # Check for bogus (non-ref) argument values if ( !ref($a) || !ref($b) ) { my @callerInfo = caller(1); die 'error: must pass array or hash references to ' . $callerInfo[3]; } # set up code refs # Note that these are optimized. if ( !defined($keyGen) ) # optimize for strings { $keyGen = sub { $_[0] }; $compare = sub { my ( $a, $b ) = @_; $a eq $b }; } else { $compare = sub { my $a = shift; my $b = shift; &$keyGen( $a, @_ ) eq &$keyGen( $b, @_ ); }; } my ( $aStart, $aFinish, $matchVector ) = ( 0, $#$a, [] ); my ( $prunedCount, $bMatches ) = ( 0, {} ); if ( ref($b) eq 'HASH' ) # was $bMatches prepared for us? { $bMatches = $b; } else { my ( $bStart, $bFinish ) = ( 0, $#$b ); # First we prune off any common elements at the beginning while ( $aStart <= $aFinish and $bStart <= $bFinish and &$compare( $a->[$aStart], $b->[$bStart], @_ ) ) { $matchVector->[ $aStart++ ] = $bStart++; $prunedCount++; } # now the end while ( $aStart <= $aFinish and $bStart <= $bFinish and &$compare( $a->[$aFinish], $b->[$bFinish], @_ ) ) { $matchVector->[ $aFinish-- ] = $bFinish--; $prunedCount++; } # Now compute the equivalence classes of positions of elements $bMatches = _withPositionsOfInInterval( $b, $bStart, $bFinish, $keyGen, @_ ); } my $thresh = []; my $links = []; my ( $i, $ai, $j, $k ); for ( $i = $aStart ; $i <= $aFinish ; $i++ ) { $ai = &$keyGen( $a->[$i], @_ ); if ( exists( $bMatches->{$ai} ) ) { $k = 0; for $j ( @{ $bMatches->{$ai} } ) { # optimization: most of the time this will be true if ( $k and $thresh->[$k] > $j and $thresh->[ $k - 1 ] < $j ) { $thresh->[$k] = $j; } else { $k = _replaceNextLargerWith( $thresh, $j, $k ); } # oddly, it's faster to always test this (CPU cache?). if ( defined($k) ) { $links->[$k] = [ ( $k ? $links->[ $k - 1 ] : undef ), $i, $j ]; } } } } if (@$thresh) { return $prunedCount + @$thresh if $counting; for ( my $link = $links->[$#$thresh] ; $link ; $link = $link->[0] ) { $matchVector->[ $link->[1] ] = $link->[2]; } } elsif ($counting) { return $prunedCount; } return wantarray ? @$matchVector : $matchVector; } sub traverse_sequences { my $a = shift; # array ref my $b = shift; # array ref my $callbacks = shift || {}; my $keyGen = shift; my $matchCallback = $callbacks->{'MATCH'} || sub { }; my $discardACallback = $callbacks->{'DISCARD_A'} || sub { }; my $finishedACallback = $callbacks->{'A_FINISHED'}; my $discardBCallback = $callbacks->{'DISCARD_B'} || sub { }; my $finishedBCallback = $callbacks->{'B_FINISHED'}; my $matchVector = _longestCommonSubsequence( $a, $b, 0, $keyGen, @_ ); # Process all the lines in @$matchVector my $lastA = $#$a; my $lastB = $#$b; my $bi = 0; my $ai; for ( $ai = 0 ; $ai <= $#$matchVector ; $ai++ ) { my $bLine = $matchVector->[$ai]; if ( defined($bLine) ) # matched { &$discardBCallback( $ai, $bi++, @_ ) while $bi < $bLine; &$matchCallback( $ai, $bi++, @_ ); } else { &$discardACallback( $ai, $bi, @_ ); } } # The last entry (if any) processed was a match. # $ai and $bi point just past the last matching lines in their sequences. while ( $ai <= $lastA or $bi <= $lastB ) { # last A? if ( $ai == $lastA + 1 and $bi <= $lastB ) { if ( defined($finishedACallback) ) { &$finishedACallback( $lastA, @_ ); $finishedACallback = undef; } else { &$discardBCallback( $ai, $bi++, @_ ) while $bi <= $lastB; } } # last B? if ( $bi == $lastB + 1 and $ai <= $lastA ) { if ( defined($finishedBCallback) ) { &$finishedBCallback( $lastB, @_ ); $finishedBCallback = undef; } else { &$discardACallback( $ai++, $bi, @_ ) while $ai <= $lastA; } } &$discardACallback( $ai++, $bi, @_ ) if $ai <= $lastA; &$discardBCallback( $ai, $bi++, @_ ) if $bi <= $lastB; } return 1; } sub traverse_balanced { my $a = shift; # array ref my $b = shift; # array ref my $callbacks = shift || {}; my $keyGen = shift; my $matchCallback = $callbacks->{'MATCH'} || sub { }; my $discardACallback = $callbacks->{'DISCARD_A'} || sub { }; my $discardBCallback = $callbacks->{'DISCARD_B'} || sub { }; my $changeCallback = $callbacks->{'CHANGE'}; my $matchVector = _longestCommonSubsequence( $a, $b, 0, $keyGen, @_ ); # Process all the lines in match vector my $lastA = $#$a; my $lastB = $#$b; my $bi = 0; my $ai = 0; my $ma = -1; my $mb; while (1) { # Find next match indices $ma and $mb do { $ma++; } while( $ma <= $#$matchVector && !defined $matchVector->[$ma] ); last if $ma > $#$matchVector; # end of matchVector? $mb = $matchVector->[$ma]; # Proceed with discard a/b or change events until # next match while ( $ai < $ma || $bi < $mb ) { if ( $ai < $ma && $bi < $mb ) { # Change if ( defined $changeCallback ) { &$changeCallback( $ai++, $bi++, @_ ); } else { &$discardACallback( $ai++, $bi, @_ ); &$discardBCallback( $ai, $bi++, @_ ); } } elsif ( $ai < $ma ) { &$discardACallback( $ai++, $bi, @_ ); } else { # $bi < $mb &$discardBCallback( $ai, $bi++, @_ ); } } # Match &$matchCallback( $ai++, $bi++, @_ ); } while ( $ai <= $lastA || $bi <= $lastB ) { if ( $ai <= $lastA && $bi <= $lastB ) { # Change if ( defined $changeCallback ) { &$changeCallback( $ai++, $bi++, @_ ); } else { &$discardACallback( $ai++, $bi, @_ ); &$discardBCallback( $ai, $bi++, @_ ); } } elsif ( $ai <= $lastA ) { &$discardACallback( $ai++, $bi, @_ ); } else { # $bi <= $lastB &$discardBCallback( $ai, $bi++, @_ ); } } return 1; } sub prepare { my $a = shift; # array ref my $keyGen = shift; # code ref # set up code ref $keyGen = sub { $_[0] } unless defined($keyGen); return scalar _withPositionsOfInInterval( $a, 0, $#$a, $keyGen, @_ ); } sub LCS { my $a = shift; # array ref my $b = shift; # array ref or hash ref my $matchVector = _longestCommonSubsequence( $a, $b, 0, @_ ); my @retval; my $i; for ( $i = 0 ; $i <= $#$matchVector ; $i++ ) { if ( defined( $matchVector->[$i] ) ) { push ( @retval, $a->[$i] ); } } return wantarray ? @retval : \@retval; } sub LCS_length { my $a = shift; # array ref my $b = shift; # array ref or hash ref return _longestCommonSubsequence( $a, $b, 1, @_ ); } sub LCSidx { my $a= shift @_; my $b= shift @_; my $match= _longestCommonSubsequence( $a, $b, 0, @_ ); my @am= grep defined $match->[$_], 0..$#$match; my @bm= @{$match}[@am]; return \@am, \@bm; } sub compact_diff { my $a= shift @_; my $b= shift @_; my( $am, $bm )= LCSidx( $a, $b, @_ ); my @cdiff; my( $ai, $bi )= ( 0, 0 ); push @cdiff, $ai, $bi; while( 1 ) { while( @$am && $ai == $am->[0] && $bi == $bm->[0] ) { shift @$am; shift @$bm; ++$ai, ++$bi; } push @cdiff, $ai, $bi; last if ! @$am; $ai = $am->[0]; $bi = $bm->[0]; push @cdiff, $ai, $bi; } push @cdiff, 0+@$a, 0+@$b if $ai < @$a || $bi < @$b; return wantarray ? @cdiff : \@cdiff; } sub diff { my $a = shift; # array ref my $b = shift; # array ref my $retval = []; my $hunk = []; my $discard = sub { push @$hunk, [ '-', $_[0], $a->[ $_[0] ] ]; }; my $add = sub { push @$hunk, [ '+', $_[1], $b->[ $_[1] ] ]; }; my $match = sub { push @$retval, $hunk if 0 < @$hunk; $hunk = [] }; traverse_sequences( $a, $b, { MATCH => $match, DISCARD_A => $discard, DISCARD_B => $add }, @_ ); &$match(); return wantarray ? @$retval : $retval; } sub sdiff { my $a = shift; # array ref my $b = shift; # array ref my $retval = []; my $discard = sub { push ( @$retval, [ '-', $a->[ $_[0] ], "" ] ) }; my $add = sub { push ( @$retval, [ '+', "", $b->[ $_[1] ] ] ) }; my $change = sub { push ( @$retval, [ 'c', $a->[ $_[0] ], $b->[ $_[1] ] ] ); }; my $match = sub { push ( @$retval, [ 'u', $a->[ $_[0] ], $b->[ $_[1] ] ] ); }; traverse_balanced( $a, $b, { MATCH => $match, DISCARD_A => $discard, DISCARD_B => $add, CHANGE => $change, }, @_ ); return wantarray ? @$retval : $retval; } ######################################## my $Root= __PACKAGE__; package Algorithm::Diff::_impl; use strict; sub _Idx() { 0 } # $me->[_Idx]: Ref to array of hunk indices # 1 # $me->[1]: Ref to first sequence # 2 # $me->[2]: Ref to second sequence sub _End() { 3 } # $me->[_End]: Diff between forward and reverse pos sub _Same() { 4 } # $me->[_Same]: 1 if pos 1 contains unchanged items sub _Base() { 5 } # $me->[_Base]: Added to range's min and max sub _Pos() { 6 } # $me->[_Pos]: Which hunk is currently selected sub _Off() { 7 } # $me->[_Off]: Offset into _Idx for current position sub _Min() { -2 } # Added to _Off to get min instead of max+1 sub Die { require Carp; Carp::confess( @_ ); } sub _ChkPos { my( $me )= @_; return if $me->[_Pos]; my $meth= ( caller(1) )[3]; Die( "Called $meth on 'reset' object" ); } sub _ChkSeq { my( $me, $seq )= @_; return $seq + $me->[_Off] if 1 == $seq || 2 == $seq; my $meth= ( caller(1) )[3]; Die( "$meth: Invalid sequence number ($seq); must be 1 or 2" ); } sub getObjPkg { my( $us )= @_; return ref $us if ref $us; return $us . "::_obj"; } sub new { my( $us, $seq1, $seq2, $opts ) = @_; my @args; for( $opts->{keyGen} ) { push @args, $_ if $_; } for( $opts->{keyGenArgs} ) { push @args, @$_ if $_; } my $cdif= Diff::compact_diff( $seq1, $seq2, @args ); my $same= 1; if( 0 == $cdif->[2] && 0 == $cdif->[3] ) { $same= 0; splice @$cdif, 0, 2; } my @obj= ( $cdif, $seq1, $seq2 ); $obj[_End] = (1+@$cdif)/2; $obj[_Same] = $same; $obj[_Base] = 0; my $me = bless \@obj, $us->getObjPkg(); $me->Reset( 0 ); return $me; } sub Reset { my( $me, $pos )= @_; $pos= int( $pos || 0 ); $pos += $me->[_End] if $pos < 0; $pos= 0 if $pos < 0 || $me->[_End] <= $pos; $me->[_Pos]= $pos || !1; $me->[_Off]= 2*$pos - 1; return $me; } sub Base { my( $me, $base )= @_; my $oldBase= $me->[_Base]; $me->[_Base]= 0+$base if defined $base; return $oldBase; } sub Copy { my( $me, $pos, $base )= @_; my @obj= @$me; my $you= bless \@obj, ref($me); $you->Reset( $pos ) if defined $pos; $you->Base( $base ); return $you; } sub Next { my( $me, $steps )= @_; $steps= 1 if ! defined $steps; if( $steps ) { my $pos= $me->[_Pos]; my $new= $pos + $steps; $new= 0 if $pos && $new < 0; $me->Reset( $new ) } return $me->[_Pos]; } sub Prev { my( $me, $steps )= @_; $steps= 1 if ! defined $steps; my $pos= $me->Next(-$steps); $pos -= $me->[_End] if $pos; return $pos; } sub Diff { my( $me )= @_; $me->_ChkPos(); return 0 if $me->[_Same] == ( 1 & $me->[_Pos] ); my $ret= 0; my $off= $me->[_Off]; for my $seq ( 1, 2 ) { $ret |= $seq if $me->[_Idx][ $off + $seq + _Min ] < $me->[_Idx][ $off + $seq ]; } return $ret; } sub Min { my( $me, $seq, $base )= @_; $me->_ChkPos(); my $off= $me->_ChkSeq($seq); $base= $me->[_Base] if !defined $base; return $base + $me->[_Idx][ $off + _Min ]; } sub Max { my( $me, $seq, $base )= @_; $me->_ChkPos(); my $off= $me->_ChkSeq($seq); $base= $me->[_Base] if !defined $base; return $base + $me->[_Idx][ $off ] -1; } sub Range { my( $me, $seq, $base )= @_; $me->_ChkPos(); my $off = $me->_ChkSeq($seq); if( !wantarray ) { return $me->[_Idx][ $off ] - $me->[_Idx][ $off + _Min ]; } $base= $me->[_Base] if !defined $base; return ( $base + $me->[_Idx][ $off + _Min ] ) .. ( $base + $me->[_Idx][ $off ] - 1 ); } sub Items { my( $me, $seq )= @_; $me->_ChkPos(); my $off = $me->_ChkSeq($seq); if( !wantarray ) { return $me->[_Idx][ $off ] - $me->[_Idx][ $off + _Min ]; } return @{$me->[$seq]}[ $me->[_Idx][ $off + _Min ] .. ( $me->[_Idx][ $off ] - 1 ) ]; } sub Same { my( $me )= @_; $me->_ChkPos(); return wantarray ? () : 0 if $me->[_Same] != ( 1 & $me->[_Pos] ); return $me->Items(1); } my %getName; BEGIN { %getName= ( same => \&Same, diff => \&Diff, base => \&Base, min => \&Min, max => \&Max, range=> \&Range, items=> \&Items, # same thing ); } sub Get { my $me= shift @_; $me->_ChkPos(); my @value; for my $arg ( @_ ) { for my $word ( split ' ', $arg ) { my $meth; if( $word !~ /^(-?\d+)?([a-zA-Z]+)([12])?$/ || not $meth= $getName{ lc $2 } ) { Die( $Root, ", Get: Invalid request ($word)" ); } my( $base, $name, $seq )= ( $1, $2, $3 ); push @value, scalar( 4 == length($name) ? $meth->( $me ) : $meth->( $me, $seq, $base ) ); } } if( wantarray ) { return @value; } elsif( 1 == @value ) { return $value[0]; } Die( 0+@value, " values requested from ", $Root, "'s Get in scalar context" ); } my $Obj= getObjPkg($Root); no strict 'refs'; for my $meth ( qw( new getObjPkg ) ) { *{$Root."::".$meth} = \&{$meth}; *{$Obj ."::".$meth} = \&{$meth}; } for my $meth ( qw( Next Prev Reset Copy Base Diff Same Items Range Min Max Get _ChkPos _ChkSeq ) ) { *{$Obj."::".$meth} = \&{$meth}; } 1; __END__ =head1 NAME Algorithm::Diff - Compute `intelligent' differences between two files / lists =head1 SYNOPSIS require Algorithm::Diff; # This example produces traditional 'diff' output: my $diff = Algorithm::Diff->new( \@seq1, \@seq2 ); $diff->Base( 1 ); # Return line numbers, not indices while( $diff->Next() ) { next if $diff->Same(); my $sep = ''; if( ! $diff->Items(2) ) { printf "%d,%dd%d\n", $diff->Get(qw( Min1 Max1 Max2 )); } elsif( ! $diff->Items(1) ) { printf "%da%d,%d\n", $diff->Get(qw( Max1 Min2 Max2 )); } else { $sep = "---\n"; printf "%d,%dc%d,%d\n", $diff->Get(qw( Min1 Max1 Min2 Max2 )); } print "< $_" for $diff->Items(1); print $sep; print "> $_" for $diff->Items(2); } # Alternate interfaces: use Algorithm::Diff qw( LCS LCS_length LCSidx diff sdiff compact_diff traverse_sequences traverse_balanced ); @lcs = LCS( \@seq1, \@seq2 ); $lcsref = LCS( \@seq1, \@seq2 ); $count = LCS_length( \@seq1, \@seq2 ); ( $seq1idxref, $seq2idxref ) = LCSidx( \@seq1, \@seq2 ); # Complicated interfaces: @diffs = diff( \@seq1, \@seq2 ); @sdiffs = sdiff( \@seq1, \@seq2 ); @cdiffs = compact_diff( \@seq1, \@seq2 ); traverse_sequences( \@seq1, \@seq2, { MATCH => \&callback1, DISCARD_A => \&callback2, DISCARD_B => \&callback3, }, \&key_generator, @extra_args, ); traverse_balanced( \@seq1, \@seq2, { MATCH => \&callback1, DISCARD_A => \&callback2, DISCARD_B => \&callback3, CHANGE => \&callback4, }, \&key_generator, @extra_args, ); =head1 INTRODUCTION (by Mark-Jason Dominus) I once read an article written by the authors of C; they said that they worked very hard on the algorithm until they found the right one. I think what they ended up using (and I hope someone will correct me, because I am not very confident about this) was the `longest common subsequence' method. In the LCS problem, you have two sequences of items: a b c d f g h j q z a b c d e f g i j k r x y z and you want to find the longest sequence of items that is present in both original sequences in the same order. That is, you want to find a new sequence I which can be obtained from the first sequence by deleting some items, and from the secend sequence by deleting other items. You also want I to be as long as possible. In this case I is a b c d f g j z From there it's only a small step to get diff-like output: e h i k q r x y + - + + - + + + This module solves the LCS problem. It also includes a canned function to generate C-like output. It might seem from the example above that the LCS of two sequences is always pretty obvious, but that's not always the case, especially when the two sequences have many repeated elements. For example, consider a x b y c z p d q a b c a x b y c z A naive approach might start by matching up the C and C that appear at the beginning of each sequence, like this: a x b y c z p d q a b c a b y c z This finds the common subsequence C. But actually, the LCS is C: a x b y c z p d q a b c a x b y c z or a x b y c z p d q a b c a x b y c z =head1 USAGE (See also the README file and several example scripts include with this module.) This module now provides an object-oriented interface that uses less memory and is easier to use than most of the previous procedural interfaces. It also still provides several exportable functions. We'll deal with these in ascending order of difficulty: C, C, C, OO interface, C, C, C, C, and C. =head2 C Given references to two lists of items, LCS returns an array containing their longest common subsequence. In scalar context, it returns a reference to such a list. @lcs = LCS( \@seq1, \@seq2 ); $lcsref = LCS( \@seq1, \@seq2 ); C may be passed an optional third parameter; this is a CODE reference to a key generation function. See L. @lcs = LCS( \@seq1, \@seq2, \&keyGen, @args ); $lcsref = LCS( \@seq1, \@seq2, \&keyGen, @args ); Additional parameters, if any, will be passed to the key generation routine. =head2 C This is just like C except it only returns the length of the longest common subsequence. This provides a performance gain of about 9% compared to C. =head2 C Like C except it returns references to two arrays. The first array contains the indices into @seq1 where the LCS items are located. The second array contains the indices into @seq2 where the LCS items are located. Therefore, the following three lists will contain the same values: my( $idx1, $idx2 ) = LCSidx( \@seq1, \@seq2 ); my @list1 = @seq1[ @$idx1 ]; my @list2 = @seq2[ @$idx2 ]; my @list3 = LCS( \@seq1, \@seq2 ); =head2 C $diff = Algorithm::Diffs->new( \@seq1, \@seq2 ); $diff = Algorithm::Diffs->new( \@seq1, \@seq2, \%opts ); C computes the smallest set of additions and deletions necessary to turn the first sequence into the second and compactly records them in the object. You use the object to iterate over I, where each hunk represents a contiguous section of items which should be added, deleted, replaced, or left unchanged. =over 4 The following summary of all of the methods looks a lot like Perl code but some of the symbols have different meanings: [ ] Encloses optional arguments : Is followed by the default value for an optional argument | Separates alternate return results Method summary: $obj = Algorithm::Diff->new( \@seq1, \@seq2, [ \%opts ] ); $pos = $obj->Next( [ $count : 1 ] ); $revPos = $obj->Prev( [ $count : 1 ] ); $obj = $obj->Reset( [ $pos : 0 ] ); $copy = $obj->Copy( [ $pos, [ $newBase ] ] ); $oldBase = $obj->Base( [ $newBase ] ); Note that all of the following methods C if used on an object that is "reset" (not currently pointing at any hunk). $bits = $obj->Diff( ); @items|$cnt = $obj->Same( ); @items|$cnt = $obj->Items( $seqNum ); @idxs |$cnt = $obj->Range( $seqNum, [ $base ] ); $minIdx = $obj->Min( $seqNum, [ $base ] ); $maxIdx = $obj->Max( $seqNum, [ $base ] ); @values = $obj->Get( @names ); Passing in C for an optional argument is always treated the same as if no argument were passed in. =item C $pos = $diff->Next(); # Move forward 1 hunk $pos = $diff->Next( 2 ); # Move forward 2 hunks $pos = $diff->Next(-5); # Move backward 5 hunks C moves the object to point at the next hunk. The object starts out "reset", which means it isn't pointing at any hunk. If the object is reset, then C moves to the first hunk. C returns a true value iff the move didn't go past the last hunk. So C will return true iff the object is not reset. Actually, C returns the object's new position, which is a number between 1 and the number of hunks (inclusive), or returns a false value. =item C C is almost identical to C; it moves to the $Nth previous hunk. On a 'reset' object, C [and C] move to the last hunk. The position returned by C is relative to the I of the hunks; -1 for the last hunk, -2 for the second-to-last, etc. =item C $diff->Reset(); # Reset the object's position $diff->Reset($pos); # Move to the specified hunk $diff->Reset(1); # Move to the first hunk $diff->Reset(-1); # Move to the last hunk C returns the object, so, for example, you could use C<< $diff->Reset()->Next(-1) >> to get the number of hunks. =item C $copy = $diff->Copy( $newPos, $newBase ); C returns a copy of the object. The copy and the orignal object share most of their data, so making copies takes very little memory. The copy maintains its own position (separate from the original), which is the main purpose of copies. It also maintains its own base. By default, the copy's position starts out the same as the original object's position. But C takes an optional first argument to set the new position, so the following three snippets are equivalent: $copy = $diff->Copy($pos); $copy = $diff->Copy(); $copy->Reset($pos); $copy = $diff->Copy()->Reset($pos); C takes an optional second argument to set the base for the copy. If you wish to change the base of the copy but leave the position the same as in the original, here are two equivalent ways: $copy = $diff->Copy(); $copy->Base( 0 ); $copy = $diff->Copy(undef,0); Here are two equivalent way to get a "reset" copy: $copy = $diff->Copy(0); $copy = $diff->Copy()->Reset(); =item C $bits = $obj->Diff(); C returns a true value iff the current hunk contains items that are different between the two sequences. It actually returns one of the follow 4 values: =over 4 =item 3 C<3==(1|2)>. This hunk contains items from @seq1 and the items from @seq2 that should replace them. Both sequence 1 and 2 contain changed items so both the 1 and 2 bits are set. =item 2 This hunk only contains items from @seq2 that should be inserted (not items from @seq1). Only sequence 2 contains changed items so only the 2 bit is set. =item 1 This hunk only contains items from @seq1 that should be deleted (not items from @seq2). Only sequence 1 contains changed items so only the 1 bit is set. =item 0 This means that the items in this hunk are the same in both sequences. Neither sequence 1 nor 2 contain changed items so neither the 1 nor the 2 bits are set. =back =item C C returns a true value iff the current hunk contains items that are the same in both sequences. It actually returns the list of items if they are the same or an emty list if they aren't. In a scalar context, it returns the size of the list. =item C $count = $diff->Items(2); @items = $diff->Items($seqNum); C returns the (number of) items from the specified sequence that are part of the current hunk. If the current hunk contains only insertions, then C<< $diff->Items(1) >> will return an empty list (0 in a scalar conext). If the current hunk contains only deletions, then C<< $diff->Items(2) >> will return an empty list (0 in a scalar conext). If the hunk contains replacements, then both C<< $diff->Items(1) >> and C<< $diff->Items(2) >> will return different, non-empty lists. Otherwise, the hunk contains identical items and all of the following will return the same lists: @items = $diff->Items(1); @items = $diff->Items(2); @items = $diff->Same(); =item C $count = $diff->Range( $seqNum ); @indices = $diff->Range( $seqNum ); @indices = $diff->Range( $seqNum, $base ); C is like C except that it returns a list of I to the items rather than the items themselves. By default, the index of the first item (in each sequence) is 0 but this can be changed by calling the C method. So, by default, the following two snippets return the same lists: @list = $diff->Items(2); @list = @seq2[ $diff->Range(2) ]; You can also specify the base to use as the second argument. So the following two snippets I return the same lists: @list = $diff->Items(1); @list = @seq1[ $diff->Range(1,0) ]; =item C $curBase = $diff->Base(); $oldBase = $diff->Base($newBase); C sets and/or returns the current base (usually 0 or 1) that is used when you request range information. The base defaults to 0 so that range information is returned as array indices. You can set the base to 1 if you want to report traditional line numbers instead. =item C $min1 = $diff->Min(1); $min = $diff->Min( $seqNum, $base ); C returns the first value that C would return (given the same arguments) or returns C if C would return an empty list. =item C C returns the last value that C would return or C. =item C ( $n, $x, $r ) = $diff->Get(qw( min1 max1 range1 )); @values = $diff->Get(qw( 0min2 1max2 range2 same base )); C returns one or more scalar values. You pass in a list of the names of the values you want returned. Each name must match one of the following regexes: /^(-?\d+)?(min|max)[12]$/i /^(range[12]|same|diff|base)$/i The 1 or 2 after a name says which sequence you want the information for (and where allowed, it is required). The optional number before "min" or "max" is the base to use. So the following equalities hold: $diff->Get('min1') == $diff->Min(1) $diff->Get('0min2') == $diff->Min(2,0) Using C in a scalar context when you've passed in more than one name is a fatal error (C is called). =back =head2 C Given a reference to a list of items, C returns a reference to a hash which can be used when comparing this sequence to other sequences with C or C. $prep = prepare( \@seq1 ); for $i ( 0 .. 10_000 ) { @lcs = LCS( $prep, $seq[$i] ); # do something useful with @lcs } C may be passed an optional third parameter; this is a CODE reference to a key generation function. See L. $prep = prepare( \@seq1, \&keyGen ); for $i ( 0 .. 10_000 ) { @lcs = LCS( $seq[$i], $prep, \&keyGen ); # do something useful with @lcs } Using C provides a performance gain of about 50% when calling LCS many times compared with not preparing. =head2 C @diffs = diff( \@seq1, \@seq2 ); $diffs_ref = diff( \@seq1, \@seq2 ); C computes the smallest set of additions and deletions necessary to turn the first sequence into the second, and returns a description of these changes. The description is a list of I; each hunk represents a contiguous section of items which should be added, deleted, or replaced. (Hunks containing unchanged items are not included.) The return value of C is a list of hunks, or, in scalar context, a reference to such a list. If there are no differences, the list will be empty. Here is an example. Calling C for the following two sequences: a b c e h j l m n p b c d e f j k l m r s t would produce the following list: ( [ [ '-', 0, 'a' ] ], [ [ '+', 2, 'd' ] ], [ [ '-', 4, 'h' ], [ '+', 4, 'f' ] ], [ [ '+', 6, 'k' ] ], [ [ '-', 8, 'n' ], [ '-', 9, 'p' ], [ '+', 9, 'r' ], [ '+', 10, 's' ], [ '+', 11, 't' ] ], ) There are five hunks here. The first hunk says that the C at position 0 of the first sequence should be deleted (C<->). The second hunk says that the C at position 2 of the second sequence should be inserted (C<+>). The third hunk says that the C at position 4 of the first sequence should be removed and replaced with the C from position 4 of the second sequence. And so on. C may be passed an optional third parameter; this is a CODE reference to a key generation function. See L. Additional parameters, if any, will be passed to the key generation routine. =head2 C @sdiffs = sdiff( \@seq1, \@seq2 ); $sdiffs_ref = sdiff( \@seq1, \@seq2 ); C computes all necessary components to show two sequences and their minimized differences side by side, just like the Unix-utility I does: same same before | after old < - - > new It returns a list of array refs, each pointing to an array of display instructions. In scalar context it returns a reference to such a list. If there are no differences, the list will have one entry per item, each indicating that the item was unchanged. Display instructions consist of three elements: A modifier indicator (C<+>: Element added, C<->: Element removed, C: Element unmodified, C: Element changed) and the value of the old and new elements, to be displayed side-by-side. An C of the following two sequences: a b c e h j l m n p b c d e f j k l m r s t results in ( [ '-', 'a', '' ], [ 'u', 'b', 'b' ], [ 'u', 'c', 'c' ], [ '+', '', 'd' ], [ 'u', 'e', 'e' ], [ 'c', 'h', 'f' ], [ 'u', 'j', 'j' ], [ '+', '', 'k' ], [ 'u', 'l', 'l' ], [ 'u', 'm', 'm' ], [ 'c', 'n', 'r' ], [ 'c', 'p', 's' ], [ '+', '', 't' ], ) C may be passed an optional third parameter; this is a CODE reference to a key generation function. See L. Additional parameters, if any, will be passed to the key generation routine. =head2 C C is much like C except it returns a much more compact description consisting of just one flat list of indices. An example helps explain the format: my @a = qw( a b c e h j l m n p ); my @b = qw( b c d e f j k l m r s t ); @cdiff = compact_diff( \@a, \@b ); # Returns: # @a @b @a @b # start start values values ( 0, 0, # = 0, 0, # a ! 1, 0, # b c = b c 3, 2, # ! d 3, 3, # e = e 4, 4, # f ! h 5, 5, # j = j 6, 6, # ! k 6, 7, # l m = l m 8, 9, # n p ! r s t 10, 12, # ); The 0th, 2nd, 4th, etc. entries are all indices into @seq1 (@a in the above example) indicating where a hunk begins. The 1st, 3rd, 5th, etc. entries are all indices into @seq2 (@b in the above example) indicating where the same hunk begins. So each pair of indices (except the last pair) describes where a hunk begins (in each sequence). Since each hunk must end at the item just before the item that starts the next hunk, the next pair of indices can be used to determine where the hunk ends. So, the first 4 entries (0..3) describe the first hunk. Entries 0 and 1 describe where the first hunk begins (and so are always both 0). Entries 2 and 3 describe where the next hunk begins, so subtracting 1 from each tells us where the first hunk ends. That is, the first hunk contains items C<$diff[0]> through C<$diff[2] - 1> of the first sequence and contains items C<$diff[1]> through C<$diff[3] - 1> of the second sequence. In other words, the first hunk consists of the following two lists of items: # 1st pair 2nd pair # of indices of indices @list1 = @a[ $cdiff[0] .. $cdiff[2]-1 ]; @list2 = @b[ $cdiff[1] .. $cdiff[3]-1 ]; # Hunk start Hunk end Note that the hunks will always alternate between those that are part of the LCS (those that contain unchanged items) and those that contain changes. This means that all we need to be told is whether the first hunk is a 'same' or 'diff' hunk and we can determine which of the other hunks contain 'same' items or 'diff' items. By convention, we always make the first hunk contain unchanged items. So the 1st, 3rd, 5th, etc. hunks (all odd-numbered hunks if you start counting from 1) all contain unchanged items. And the 2nd, 4th, 6th, etc. hunks (all even-numbered hunks if you start counting from 1) all contain changed items. Since @a and @b don't begin with the same value, the first hunk in our example is empty (otherwise we'd violate the above convention). Note that the first 4 index values in our example are all zero. Plug these values into our previous code block and we get: @hunk1a = @a[ 0 .. 0-1 ]; @hunk1b = @b[ 0 .. 0-1 ]; And C<0..-1> returns the empty list. Move down one pair of indices (2..5) and we get the offset ranges for the second hunk, which contains changed items. Since C<@diff[2..5]> contains (0,0,1,0) in our example, the second hunk consists of these two lists of items: @hunk2a = @a[ $cdiff[2] .. $cdiff[4]-1 ]; @hunk2b = @b[ $cdiff[3] .. $cdiff[5]-1 ]; # or @hunk2a = @a[ 0 .. 1-1 ]; @hunk2b = @b[ 0 .. 0-1 ]; # or @hunk2a = @a[ 0 .. 0 ]; @hunk2b = @b[ 0 .. -1 ]; # or @hunk2a = ( 'a' ); @hunk2b = ( ); That is, we would delete item 0 ('a') from @a. Since C<@diff[4..7]> contains (1,0,3,2) in our example, the third hunk consists of these two lists of items: @hunk3a = @a[ $cdiff[4] .. $cdiff[6]-1 ]; @hunk3a = @b[ $cdiff[5] .. $cdiff[7]-1 ]; # or @hunk3a = @a[ 1 .. 3-1 ]; @hunk3a = @b[ 0 .. 2-1 ]; # or @hunk3a = @a[ 1 .. 2 ]; @hunk3a = @b[ 0 .. 1 ]; # or @hunk3a = qw( b c ); @hunk3a = qw( b c ); Note that this third hunk contains unchanged items as our convention demands. You can continue this process until you reach the last two indices, which will always be the number of items in each sequence. This is required so that subtracting one from each will give you the indices to the last items in each sequence. =head2 C C used to be the most general facility provided by this module (the new OO interface is more powerful and much easier to use). Imagine that there are two arrows. Arrow A points to an element of sequence A, and arrow B points to an element of the sequence B. Initially, the arrows point to the first elements of the respective sequences. C will advance the arrows through the sequences one element at a time, calling an appropriate user-specified callback function before each advance. It willadvance the arrows in such a way that if there are equal elements C<$A[$i]> and C<$B[$j]> which are equal and which are part of the LCS, there will be some moment during the execution of C when arrow A is pointing to C<$A[$i]> and arrow B is pointing to C<$B[$j]>. When this happens, C will call the C callback function and then it will advance both arrows. Otherwise, one of the arrows is pointing to an element of its sequence that is not part of the LCS. C will advance that arrow and will call the C or the C callback, depending on which arrow it advanced. If both arrows point to elements that are not part of the LCS, then C will advance one of them and call the appropriate callback, but it is not specified which it will call. The arguments to C are the two sequences to traverse, and a hash which specifies the callback functions, like this: traverse_sequences( \@seq1, \@seq2, { MATCH => $callback_1, DISCARD_A => $callback_2, DISCARD_B => $callback_3, } ); Callbacks for MATCH, DISCARD_A, and DISCARD_B are invoked with at least the indices of the two arrows as their arguments. They are not expected to return any values. If a callback is omitted from the table, it is not called. Callbacks for A_FINISHED and B_FINISHED are invoked with at least the corresponding index in A or B. If arrow A reaches the end of its sequence, before arrow B does, C will call the C callback when it advances arrow B, if there is such a function; if not it will call C instead. Similarly if arrow B finishes first. C returns when both arrows are at the ends of their respective sequences. It returns true on success and false on failure. At present there is no way to fail. C may be passed an optional fourth parameter; this is a CODE reference to a key generation function. See L. Additional parameters, if any, will be passed to the key generation function. If you want to pass additional parameters to your callbacks, but don't need a custom key generation function, you can get the default by passing undef: traverse_sequences( \@seq1, \@seq2, { MATCH => $callback_1, DISCARD_A => $callback_2, DISCARD_B => $callback_3, }, undef, # default key-gen $myArgument1, $myArgument2, $myArgument3, ); C does not have a useful return value; you are expected to plug in the appropriate behavior with the callback functions. =head2 C C is an alternative to C. It uses a different algorithm to iterate through the entries in the computed LCS. Instead of sticking to one side and showing element changes as insertions and deletions only, it will jump back and forth between the two sequences and report I occurring as deletions on one side followed immediatly by an insertion on the other side. In addition to the C, C, and C callbacks supported by C, C supports a C callback indicating that one element got C by another: traverse_balanced( \@seq1, \@seq2, { MATCH => $callback_1, DISCARD_A => $callback_2, DISCARD_B => $callback_3, CHANGE => $callback_4, } ); If no C callback is specified, C will map C events to C and C actions, therefore resulting in a similar behaviour as C with different order of events. C might be a bit slower than C, noticable only while processing huge amounts of data. The C function of this module is implemented as call to C. C does not have a useful return value; you are expected to plug in the appropriate behavior with the callback functions. =head1 KEY GENERATION FUNCTIONS Most of the functions accept an optional extra parameter. This is a CODE reference to a key generating (hashing) function that should return a string that uniquely identifies a given element. It should be the case that if two elements are to be considered equal, their keys should be the same (and the other way around). If no key generation function is provided, the key will be the element as a string. By default, comparisons will use "eq" and elements will be turned into keys using the default stringizing operator '""'. Where this is important is when you're comparing something other than strings. If it is the case that you have multiple different objects that should be considered to be equal, you should supply a key generation function. Otherwise, you have to make sure that your arrays contain unique references. For instance, consider this example: package Person; sub new { my $package = shift; return bless { name => '', ssn => '', @_ }, $package; } sub clone { my $old = shift; my $new = bless { %$old }, ref($old); } sub hash { return shift()->{'ssn'}; } my $person1 = Person->new( name => 'Joe', ssn => '123-45-6789' ); my $person2 = Person->new( name => 'Mary', ssn => '123-47-0000' ); my $person3 = Person->new( name => 'Pete', ssn => '999-45-2222' ); my $person4 = Person->new( name => 'Peggy', ssn => '123-45-9999' ); my $person5 = Person->new( name => 'Frank', ssn => '000-45-9999' ); If you did this: my $array1 = [ $person1, $person2, $person4 ]; my $array2 = [ $person1, $person3, $person4, $person5 ]; Algorithm::Diff::diff( $array1, $array2 ); everything would work out OK (each of the objects would be converted into a string like "Person=HASH(0x82425b0)" for comparison). But if you did this: my $array1 = [ $person1, $person2, $person4 ]; my $array2 = [ $person1, $person3, $person4->clone(), $person5 ]; Algorithm::Diff::diff( $array1, $array2 ); $person4 and $person4->clone() (which have the same name and SSN) would be seen as different objects. If you wanted them to be considered equivalent, you would have to pass in a key generation function: my $array1 = [ $person1, $person2, $person4 ]; my $array2 = [ $person1, $person3, $person4->clone(), $person5 ]; Algorithm::Diff::diff( $array1, $array2, \&Person::hash ); This would use the 'ssn' field in each Person as a comparison key, and so would consider $person4 and $person4->clone() as equal. You may also pass additional parameters to the key generation function if you wish. =head1 ERROR CHECKING If you pass these routines a non-reference and they expect a reference, they will die with a message. =head1 AUTHOR This version released by Tye McQueen (http://perlmonks.org/?node=tye). =head1 LICENSE Parts Copyright (c) 2000-2004 Ned Konz. All rights reserved. Parts by Tye McQueen. This program is free software; you can redistribute it and/or modify it under the same terms as Perl. =head1 MAILING LIST Mark-Jason still maintains a mailing list. To join a low-volume mailing list for announcements related to diff and Algorithm::Diff, send an empty mail message to mjd-perl-diff-request@plover.com. =head1 CREDITS Versions through 0.59 (and much of this documentation) were written by: Mark-Jason Dominus, mjd-perl-diff@plover.com This version borrows some documentation and routine names from Mark-Jason's, but Diff.pm's code was completely replaced. This code was adapted from the Smalltalk code of Mario Wolczko , which is available at ftp://st.cs.uiuc.edu/pub/Smalltalk/MANCHESTER/manchester/4.0/diff.st C and C were written by Mike Schilli . The algorithm is that described in I, CACM, vol.20, no.5, pp.350-353, May 1977, with a few minor improvements to improve the speed. Much work was done by Ned Konz (perl@bike-nomad.com). The OO interface and some other changes are by Tye McQueen. =cut SimGrid-3.11/buildtools/Cmake/Scripts/postinstall.sh000755 001750 001750 00000000234 12342443653 021573 0ustar00cici000000 000000 #! /bin/sh echo "export SIMGRID_ROOT=/Applications/SimGrid" >> ~/.profile echo "export DYLD_LYBRARY_PATH=$DYLD_LYBRARY_PATH:$SIMGRID_ROOT/lib" >> ~/.profileSimGrid-3.11/buildtools/Cmake/Scripts/tesh.pl000755 001750 001750 00000037674 12342443653 020205 0ustar00cici000000 000000 #! /usr/bin/perl # Copyright (c) 2012-2014. The SimGrid Team. # All rights reserved. # This program is free software; you can redistribute it and/or modify it # under the terms of the license (GNU LGPL) which comes with this package. eval 'exec perl -S $0 ${1+"$@"}' if $running_under_some_shell; =encoding UTF-8 =head1 NAME tesh -- testing shell =head1 SYNOPSIS B [I] I =cut my($bindir)="."; my($srcdir)="."; my($timeout)=0; my($time_to_wait)=0; my $path = $0; my $OS; my $enable_coverage=0; my $sort_prefix = 19; my $tesh_file; my $tesh_name; my $error=0; my $exitcode=0; my @bg_cmds; my (%environ); $path =~ s|[^/]*$||; push @INC,$path; use Getopt::Long qw(GetOptions); use strict; use Term::ANSIColor; use Text::ParseWords; use IPC::Open3; use IO::File; if($^O eq "linux"){ $OS = "UNIX"; } else{ $OS = "WIN"; $ENV{"PRINTF_EXPONENT_DIGITS"} = "2"; } ## ## Command line option handling ## sub var_subst { my ($text, $name, $value) = @_; if ($value) { $text =~ s/\${$name(?::[=-][^}]*)?}/$value/g; $text =~ s/\$$name(\W|$)/$value$1/g; } else { $text =~ s/\${$name:=([^}]*)}/$1/g; $text =~ s/\${$name}//g; $text =~ s/\$$name(\W|$)/$1/g; } return $text; } # option handling helper subs sub cd_cmd { my $directory=$_[1]; my $failure=1; if (-e $directory && -d $directory) { chdir("$directory"); print "[Tesh/INFO] change directory to $directory\n"; $failure=0; } elsif (-e $directory) { print "Cannot change directory to '$directory': it is not a directory\n"; } else { print "Chdir to $directory failed: No such file or directory\n"; } if($failure==1){ $error=1; $exitcode=4; print "Test suite `$tesh_file': NOK (system error)\n"; exit 4; } } sub setenv_cmd { my($var,$ctn); if ($_[0] =~ /^(.*)=(.*)$/) { ($var,$ctn)=($1,$2); }elsif ($_[1] =~ /^(.*)=(.*)$/) { ($var,$ctn)=($1,$2); } else { die "[Tesh/CRITICAL] Malformed argument to setenv: expected 'name=value' but got '$_[1]'\n"; } print "[Tesh/INFO] setenv $var=$ctn\n"; $environ{$var} = $ctn; } # Main option parsing sub sub get_options { # remove the tesh file from the ARGV used my @ARGV = @_; $tesh_file = pop @ARGV; # temporary arrays for GetOption my @verbose = (); my @cfg; my $log; # ignored my %opt = ( "help" => 0, "debug" => 0, "verbose" => 0 ); Getopt::Long::config('bundling', 'no_getopt_compat', 'no_auto_abbrev'); GetOptions( 'help|h' => \$opt{'help'}, 'verbose|v' => \@verbose, 'debug|d' => \$opt{"debug"}, 'cd=s' => \&cd_cmd, 'timeout=s' => \$opt{'timeout'}, 'setenv=s' => \&setenv_cmd, 'cfg=s' => \@cfg, 'log=s' => \$log, 'enable-coverage+' => \$enable_coverage, ); if($enable_coverage){ print "Enable coverage\n"; } unless($tesh_file=~/(.*)\.tesh/){ $tesh_file="(stdin)"; $tesh_name="(stdin)"; print "Test suite from stdin\n"; }else{ $tesh_name=$1; print "Test suite `$tesh_name'\n"; } $opt{'verbose'} = scalar @verbose; foreach (@cfg) { $opt{'cfg'} .= " --cfg=$_"; } return %opt; } my %opts = get_options(@ARGV); ## ## File parsing ## my($nb_arg)=0; my($old_buffer); my($linebis); my($SIGABRT)=0; my($verbose)=0; my($return)=-1; my($pid); my($result); my($result_err); my($forked); my($config)=""; my($tesh_command)=0; my(@buffer_tesh)=(); #eval { use POSIX; sub exit_status { my $status = shift; if (POSIX::WIFEXITED($status)) { $exitcode=POSIX::WEXITSTATUS($status)+40; return "returned code ".POSIX::WEXITSTATUS($status); } elsif (POSIX::WIFSIGNALED($status)) { my $code; if (POSIX::WTERMSIG($status) == SIGINT){$code="SIGINT"; } elsif (POSIX::WTERMSIG($status) == SIGTERM) {$code="SIGTERM"; } elsif (POSIX::WTERMSIG($status) == SIGKILL) {$code= "SIGKILL"; } elsif (POSIX::WTERMSIG($status) == SIGABRT) {$code="SIGABRT"; } elsif (POSIX::WTERMSIG($status) == SIGSEGV) {$code="SIGSEGV" ;} $exitcode=POSIX::WTERMSIG($status)+4; return "got signal $code"; } return "Unparsable status. Is the process stopped?"; } #}; #if ($@) { # no POSIX available? # warn "POSIX not usable to parse the return value of forked child: $@\n"; # sub exit_status { # return "returned code -1 $@ "; # } #} sub exec_cmd { my %cmd = %{$_[0]}; if ($opts{'debug'}) { print "IN BEGIN\n"; map {print " $_"} @{$cmd{'in'}}; print "IN END\n"; print "OUT BEGIN\n"; map {print " $_"} @{$cmd{'out'}}; print "OUT END\n"; print "CMD: $cmd{'cmd'}\n"; } # cleanup the command line if($OS eq "WIN") { var_subst($cmd{'cmd'}, "EXEEXT", ".exe"); } else { var_subst($cmd{'cmd'}, "EXEEXT", ""); } # substitute environ variables foreach my $key (keys %environ) { $cmd{'cmd'} = var_subst($cmd{'cmd'}, $key, $environ{$key}); } # substitute remaining variables, if any while ($cmd{'cmd'} =~ /\${(\w+)(?::[=-][^}]*)?}/) { $cmd{'cmd'} = var_subst($cmd{'cmd'}, $1, ""); } while ($cmd{'cmd'} =~ /\$(\w+)/) { $cmd{'cmd'} = var_subst($cmd{'cmd'}, $1, ""); } # add cfg options $cmd{'cmd'} .= " $opts{'cfg'}" if (defined($opts{'cfg'}) && length($opts{'cfg'})); # final cleanup $cmd{'cmd'} =~ s/^\s+//; $cmd{'cmd'} =~ s/\s+$//; print "[$tesh_name:$cmd{'line'}] $cmd{'cmd'}\n" ; ### # exec the command line ### $line =~ s/\r//g; $cmd{'got'} = IO::File->new_tmpfile; $cmd{'got'}->autoflush(1); local *E = $cmd{'got'}; $cmd{'pid'} = open3(\*CHILD_IN, ">&E", ">&E", quotewords('\s+', 0, $cmd{'cmd'})); # push all provided input to executing child map { print CHILD_IN "$_\n"; } @{$cmd{'in'}}; close CHILD_IN; # if timeout specified, fork and kill executing child at the end of timeout if (defined($cmd{'timeout'}) or defined($opts{'timeout'})){ $time_to_wait= defined($cmd{'timeout'}) ? $cmd{'timeout'} : $opts{'timeout'}; $forked = fork(); $timeout=-1; die "fork() failed: $!" unless defined $forked; if ( $forked == 0 ) { # child sleep $time_to_wait; kill(SIGKILL, $cmd{'pid'}); exit $time_to_wait; } } # Cleanup the executing child, and kill the timeouter brother on need $cmd{'return'} = 0 unless defined($cmd{'return'}); if($cmd{'background'} != 1){ waitpid ($cmd{'pid'}, 0); $cmd{'gotret'} = exit_status($?); parse_out(\%cmd); }else{ # & commands, which will be handled at the end push @bg_cmds, \%cmd; # no timeout for background commands if($forked){ kill(SIGKILL, $forked); $timeout=0; $forked=0; } } } sub parse_out { my %cmd = %{$_[0]}; my $gotret=$cmd{'gotret'}; my $wantret; if(defined($cmd{'expect'}) and ($cmd{'expect'} ne "")){ $wantret = "got signal $cmd{'expect'}"; }else{ $wantret = "returned code ".(defined($cmd{'return'})? $cmd{'return'} : 0); } local *got = $cmd{'got'}; seek(got,0,0); # pop all output from executing child my @got; while(defined(my $got=)) { $got =~ s/\r//g; chomp $got; if (!($enable_coverage and $got=~ /^profiling:/)){ push @got, $got; } } if ($cmd{'sort'}){ sub mysort{ substr($a, 0, $sort_prefix) cmp substr($b, 0, $sort_prefix) } use sort 'stable'; @got = sort mysort @got; while (@got and $got[0] eq "") { shift @got; } #also resort the other one, as perl sort is not the same as the C one used to generate teshes if(defined($cmd{'out'})){ @{$cmd{'out'}}=sort mysort @{$cmd{'out'}}; while (@{$cmd{'out'}} and ${$cmd{'out'}}[0] eq "") { shift @{$cmd{'out'}}; } } } #Did we timeout ? If yes, handle it. If not, kill the forked process. if($timeout==-1 and $gotret eq "got signal SIGKILL"){ $gotret="return code 0"; $timeout=1; $gotret= "timeout after $time_to_wait sec"; $error=1; $exitcode=3; print STDERR "<$cmd{'file'}:$cmd{'line'}> timeouted. Kill the process.\n"; }else{ $timeout=0; } if($gotret ne $wantret) { $error=1; my $msg = "Test suite `$cmd{'file'}': NOK (<$cmd{'file'}:$cmd{'line'}> $gotret)\n"; if ($timeout!=1) { $msg=$msg."Output of <$cmd{'file'}:$cmd{'line'}> so far:\n"; } map {$msg .= "|| $_\n"} @got; if(!@got) { if($timeout==1){ print STDERR "<$cmd{'file'}:$cmd{'line'}> No output before timeout\n"; }else{ $msg .= "||\n"; } } $timeout = 0; print STDERR "$msg"; } ### # Check the result of execution ### my $diff; if (defined($cmd{'output display'})){ print "[Tesh/INFO] Here is the (ignored) command output:\n"; map { print "||$_\n" } \@got; } elsif (!defined($cmd{'output ignore'})){ $diff = build_diff(\@{$cmd{'out'}}, \@got); }else{ print "(ignoring the output of <$cmd{'file'}:$cmd{'line'}> as requested)\n" } if (length $diff) { print "Output of <$cmd{'file'}:$cmd{'line'}> mismatch:\n"; map { print "$_\n" } split(/\n/,$diff); print "Test suite `$cmd{'file'}': NOK (<$cmd{'file'}:$cmd{'line'}> output mismatch)\n"; $error=1; $exitcode=2; } } sub mkfile_cmd { my %cmd = %{$_[0]}; my $file = $cmd{'arg'}; print "[Tesh/INFO] mkfile $file\n"; unlink($file); open(FILE,">$file") or die "[Tesh/CRITICAL] Unable to create file $file: $!\n"; print FILE join("\n", @{$cmd{'in'}}); print FILE "\n" if (scalar @{$cmd{'in'}} > 0); close(FILE); } # parse tesh file #my $teshfile=$tesh_file; #$teshfile=~ s{\.[^.]+$}{}; unless($tesh_file eq "(stdin)"){ open TESH_FILE, $tesh_file or die "[Tesh/CRITICAL] Unable to open $tesh_file $!\n"; } my %cmd; # everything about the next command to run my $line_num=0; my $finished =0; LINE: while (not $finished and not $error) { my $line; if ($tesh_file ne "(stdin)" and !defined($line=)){ $finished=1; next LINE; }elsif ($tesh_file eq "(stdin)" and !defined($line=<>)){ $finished=1; next LINE; } $line_num++; chomp $line; $line =~ s/\r//g; print "[TESH/debug] $line_num: $line\n" if $opts{'debug'}; my $next; # deal with line continuations while ($line =~ /^(.*?)\\$/) { $next=; die "[TESH/CRITICAL] Continued line at end of file\n" unless defined($next); $line_num++; chomp $next; print "[TESH/debug] $line_num: $next\n" if $opts{'debug'}; $line = $1.$next; } # Push delayed commands on empty lines unless ($line =~ m/^(.)(.*)$/) { if (defined($cmd{'cmd'})) { exec_cmd(\%cmd); %cmd = (); } next LINE; } my ($cmd,$arg) = ($1,$2); $arg =~ s/^ //g; $arg =~ s/\r//g; $arg =~ s/\\\\/\\/g; # handle the commands if ($cmd =~ /^#/) { #comment } elsif ($cmd eq '>'){ #expected result line print "[TESH/debug] push expected result\n" if $opts{'debug'}; push @{$cmd{'out'}}, $arg; } elsif ($cmd eq '<') { # provided input print "[TESH/debug] push provided input\n" if $opts{'debug'}; push @{$cmd{'in'}}, $arg; } elsif ($cmd eq 'p') { # comment print "[$tesh_name:$line_num] $arg\n"; } elsif ($cmd eq '$') { # Command # if we have something buffered, run it now if (defined($cmd{'cmd'})) { exec_cmd(\%cmd); %cmd = (); } if ($arg =~ /^\s*mkfile /){ # "mkfile" command line die "[TESH/CRITICAL] Output expected from mkfile command!\n" if scalar @{cmd{'out'}}; $cmd{'arg'} = $arg; $cmd{'arg'} =~ s/\s*mkfile //; mkfile_cmd(\%cmd); %cmd = (); } elsif ($arg =~ /^\s*cd /) { die "[TESH/CRITICAL] Input provided to cd command!\n" if scalar @{cmd{'in'}}; die "[TESH/CRITICAL] Output expected from cd command!\n" if scalar @{cmd{'out'}}; $arg =~ s/^ *cd //; cd_cmd("",$arg); %cmd = (); } else { # regular command $cmd{'cmd'} = $arg; $cmd{'file'} = $tesh_file; $cmd{'line'} = $line_num; } } elsif($cmd eq '&'){ # parallel command line if (defined($cmd{'cmd'})) { exec_cmd(\%cmd); %cmd = (); } $cmd{'background'} = 1; $cmd{'cmd'} = $arg; $cmd{'file'} = $tesh_file; $cmd{'line'} = $line_num; } elsif($line =~ /^!\s*output sort/){ #output sort if (defined($cmd{'cmd'})) { exec_cmd(\%cmd); %cmd = (); } $cmd{'sort'} = 1; if ($line =~ /^!\s*output sort\s+(\d+)/) { $sort_prefix = $1; } } elsif($line =~ /^!\s*output ignore/){ #output ignore if (defined($cmd{'cmd'})) { exec_cmd(\%cmd); %cmd = (); } $cmd{'output ignore'} = 1; } elsif($line =~ /^!\s*output display/){ #output display if (defined($cmd{'cmd'})) { exec_cmd(\%cmd); %cmd = (); } $cmd{'output display'} = 1; } elsif($line =~ /^!\s*expect signal (\w*)/) {#expect signal SIGABRT if (defined($cmd{'cmd'})) { exec_cmd(\%cmd); %cmd = (); } print "hey\n"; $cmd{'expect'} = "$1"; } elsif($line =~ /^!\s*expect return/){ #expect return if (defined($cmd{'cmd'})) { exec_cmd(\%cmd); %cmd = (); } $line =~ s/^! expect return //g; $line =~ s/\r//g; $cmd{'return'} = $line; } elsif($line =~ /^!\s*setenv/){ #setenv if (defined($cmd{'cmd'})) { exec_cmd(\%cmd); %cmd = (); } $line =~ s/^! setenv //g; $line =~ s/\r//g; setenv_cmd($line); } elsif($line =~ /^!\s*include/){ #include if (defined($cmd{'cmd'})) { exec_cmd(\%cmd); %cmd = (); } print color("red"), "[Tesh/CRITICAL] need include"; print color("reset"), "\n"; die; } elsif($line =~ /^!\s*timeout/){ #timeout if (defined($cmd{'cmd'})) { exec_cmd(\%cmd); %cmd = (); } $line =~ s/^! timeout //; $line =~ s/\r//g; $cmd{'timeout'} = $line; } else { die "[TESH/CRITICAL] parse error: $line\n"; } if($forked){ kill(SIGKILL, $forked); $timeout=0; } } # Deal with last command if (defined($cmd{'cmd'})) { exec_cmd(\%cmd); %cmd = (); } if($forked){ kill(SIGKILL, $forked); $timeout=0; } foreach(@bg_cmds){ my %test=%{$_}; waitpid ($test{'pid'}, 0); $test{'gotret'} = exit_status($?); parse_out(\%test); } @bg_cmds=(); if($error !=0){ exit $exitcode; }elsif($tesh_file eq "(stdin)"){ print "Test suite from stdin OK\n"; }else{ print "Test suite `$tesh_name' OK\n"; } #my (@a,@b); #push @a,"bl1"; push @b,"bl1"; #push @a,"bl2"; push @b,"bl2"; #push @a,"bl3"; push @b,"bl3"; #push @a,"bl4"; push @b,"bl4"; #push @a,"bl5"; push @b,"bl5"; #push @a,"bl6"; push @b,"bl6"; #push @a,"bl7"; push @b,"bl7"; ##push @a,"Perl"; push @b,"ruby"; #push @a,"END1"; push @b,"END1"; #push @a,"END2"; push @b,"END2"; #push @a,"END3"; push @b,"END3"; #push @a,"END4"; push @b,"END4"; #push @a,"END5"; push @b,"END5"; #push @a,"END6"; push @b,"END6"; #push @a,"END7"; push @b,"END7"; #print "Identical:\n". build_diff(\@a,\@b); #@a = (); @b =(); #push @a,"AZE"; push @b,"EZA"; #print "Different:\n".build_diff(\@a,\@b); use lib "@CMAKE_BINARY_DIR@/bin" ; use Diff qw(diff); # postpone a bit to have time to change INC sub build_diff { my $res; my $diff = Diff->new(@_); $diff->Base( 1 ); # Return line numbers, not indices my $chunk_count = $diff->Next(-1); # Compute the amount of chuncks return "" if ($chunk_count == 1 && $diff->Same()); $diff->Reset(); while( $diff->Next() ) { my @same = $diff->Same(); if ($diff->Same() ) { if ($diff->Next(0) > 1) { # not first chunk: print 2 first lines $res .= ' '.$same[0]."\n" ; $res .= ' '.$same[1]."\n" if (scalar @same>1); } $res .= "...\n" if (scalar @same>2); # $res .= $diff->Next(0)."/$chunk_count\n"; if ($diff->Next(0) < $chunk_count) { # not last chunk: print 2 last lines $res .= ' '.$same[scalar @same -2]."\n" if (scalar @same>1); $res .= ' '.$same[scalar @same -1]."\n"; } } next if $diff->Same(); map { $res .= "- $_\n" } $diff->Items(1); map { $res .= "+ $_\n" } $diff->Items(2); } return $res; } SimGrid-3.11/buildtools/Cmake/Scripts/java_bundle.sh000755 001750 001750 00000002276 12342443653 021501 0ustar00cici000000 000000 #!/bin/sh set -e #set -x if [ $# -lt 3 ]; then cat >&2 <&2 <&2 < Hierarchy Attributes Documents Background Image IFPkgFlagBackgroundAlignment 6 IFPkgFlagBackgroundScaling 2 Mode 1 Path ../../doc/webcruft/simgrid_logo_2011.gif Path Type 2 License International Mode 0 Path ../../LICENSE-LGPL-2.1 Path Type 2 ReadMe International Mode 0 Path ../../README Path Type 2 Welcome International Mode 0 Path Path Type 2 Files Compress Hierarchy Children Children Children GID 80 Path SimGrid Path Type 1 Privileges 509 Type 2 UID 0 Children GID 80 Path Utilities Path Type 1 Privileges 509 Type 1 UID 0 GID 80 Path Applications Path Type 1 Privileges 509 Type 1 UID 0 Children Children GID 80 Path Application Support Path Type 1 Privileges 509 Type 1 UID 0 Children GID 80 Path Documentation Path Type 1 Privileges 509 Type 1 UID 0 Children GID 80 Path Filesystems Path Type 1 Privileges 509 Type 1 UID 0 Children GID 80 Path Frameworks Path Type 1 Privileges 509 Type 1 UID 0 Children GID 80 Path Internet Plug-Ins Path Type 1 Privileges 509 Type 1 UID 0 Children GID 80 Path PreferencePanes Path Type 1 Privileges 509 Type 1 UID 0 Children GID 80 Path Preferences Path Type 1 Privileges 509 Type 1 UID 0 Children GID 80 Path Printers Path Type 1 Privileges 509 Type 1 UID 0 Children GID 80 Path QuickTime Path Type 1 Privileges 509 Type 1 UID 0 Children GID 80 Path Scripts Path Type 1 Privileges 509 Type 1 UID 0 GID 80 Path Library Path Type 1 Privileges 1021 Type 1 UID 0 Children Children Children GID 0 Path Extensions Path Type 1 Privileges 493 Type 1 UID 0 GID 0 Path Library Path Type 1 Privileges 493 Type 1 UID 0 GID 0 Path System Path Type 1 Privileges 493 Type 1 UID 0 GID 80 Path / Path Type 1 Privileges 1021 Type 1 UID 0 IFPkgFlagDefaultLocation /Applications/SimGrid Imported Package Package Path Split Forks Plugins PluginsList Path Introduction Type 0 Path ReadMe Type 0 Path License Type 0 Path Target Type 0 Path PackageSelection Type 0 Path Install Type 0 Path FinishUp Type 0 Scripts Additional Resources International Installation Scripts IFInstallationScriptsPostflight Path Status IFInstallationScriptsPostinstall Path postinstall.sh Path Type 2 Status IFInstallationScriptsPostupgrade Path Status IFInstallationScriptsPreflight Path Status IFInstallationScriptsPreinstall Path preinstall.sh Path Type 2 Status IFInstallationScriptsPreupgrade Path Status Requirements Settings Description International IFPkgDescriptionDeleteWarning IFPkgDescriptionDescription SimGrid is a toolkit that provides core functionalities for the simulation of distributed applications in heterogeneous distributed environments. The specific goal of the project is to facilitate research in the area of parallel and distributed large scale systems, such as Grids, P2P systems and clouds. Its use cases encompass heuristic evaluation, application prototyping or even real application development and tuning. IFPkgDescriptionTitle SimGrid IFPkgDescriptionVersion 3.8 Display Information CFBundleGetInfoString SimGrid 1.0 Copyrights © 2012 My Great Company CFBundleIconFile ../../doc/webcruft/SGicon.icns CFBundleIconFile Path Type 2 CFBundleIdentifier com.mygreatcompany.pkg.SimGrid CFBundleName SimGrid CFBundleShortVersionString 1.0 Options IFPkgFlagAllowBackRev IFPkgFlagAuthorizationAction 0 IFPkgFlagFollowLinks IFPkgFlagIsRequired IFPkgFlagOverwritePermissions IFPkgFlagRelocatable IFPkgFlagRestartAction 0 IFPkgFlagRootVolumeOnly IFPkgFlagUpdateInstalledLanguages Version IFMajorVersion 3 IFMinorVersion 8 IFPkgFlagPackageSelection 0 Name SimGrid-3.8 Status 1 Type 1 Name Project Settings 10.1 Compatibility Build Path build Build Path Type 2 Comment Remove .DS_Store Remove .pbdevelopment Remove CVS SimGrid-3.11/buildtools/Cmake/Scripts/Makefile.default000644 001750 001750 00000000375 12342443653 021751 0ustar00cici000000 000000 #THIS Makefile should be erase by Cmake when use command "cmake." all : @echo "THIS COMMAND IS NOT AVAILABLE!" @echo "Since v3.4 we use Cmake. Now use:" @echo "\tcmake -DCMAKE_INSTALL_PREFIX= .\n\tmake\n\tmake install" clean : all SimGrid-3.11/buildtools/Cmake/Scripts/update_tesh.pl000755 001750 001750 00000002133 12342443653 021525 0ustar00cici000000 000000 #!/usr/bin/perl -w # Copyright (c) 2012, 2014. The SimGrid Team. # All rights reserved. # This program is free software; you can redistribute it and/or modify it # under the terms of the license (GNU LGPL) which comes with this package. use strict; if($#ARGV!=1) { die "Usage: perl make_tesh.pl \n"; } my($directory)=$ARGV[0]; my($old)=$ARGV[1]; chdir("$directory"); open SH_LIGNE, $old or die "Unable to open $old. $!\n"; my($line); my($line_exec); my($l); my($tmp); while(defined($line=)) { if($line =~ /^\$(.*)$/) { $line_exec = $line; $line =~ s/\$\{srcdir\:\=\.\}/./g; $line =~ s/\(/\\(/g; $line =~ s/\)/\\)/g; $line =~ s/\$SG_TEST_EXENV//g; $line =~ s/\$EXEEXT//g; $line =~ s/^\$\ */.\//g; $line =~ s/^.\/lua/lua/g; $line =~ s/^.\/ruby/ruby/g; $line =~ s/--log=([^ ]*)/--log="$1"/g; print "$line_exec"; chomp $line; open (FILE, "$line 2>&1|"); while(defined($l=)) { chomp $l; print "\> $l\n"; } close(FILE); } else { if($line =~ /^\>(.*)$/) { } else { print "$line"; } } } close(SH_LIGNE); SimGrid-3.11/buildtools/Cmake/CompleteInFiles.cmake000644 001750 001750 00000101161 12342443653 021256 0ustar00cici000000 000000 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Modules ) # x86_64 # x86 # i.86 ### Determine the assembly flavor that we need today include(CMakeDetermineSystem) IF(CMAKE_SYSTEM_PROCESSOR MATCHES ".86|AMD64|amd64") IF(${ARCH_32_BITS}) message(STATUS "System processor: i686 (${CMAKE_SYSTEM_PROCESSOR}, 32 bits)") set(PROCESSOR_i686 1) ELSE() message(STATUS "System processor: x86_64 (${CMAKE_SYSTEM_PROCESSOR}, 64 bits)") set(PROCESSOR_x86_64 1) ENDIF() set(HAVE_RAWCTX 1) ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "^alpha") message(STATUS "System processor: alpha") ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm") # Subdir is "arm" for both big-endian (arm) and little-endian (armel). message(STATUS "System processor: arm") ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "^mips") # mips* machines are bi-endian mostly so processor does not tell # endianess of the underlying system. message(STATUS "System processor: ${CMAKE_SYSTEM_PROCESSOR}" "mips" "mipsel" "mipseb") ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64") message(STATUS "System processor: ppc64") ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)") message(STATUS "System processor: ppc") ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "^sparc") # Both flavours can run on the same processor message(STATUS "System processor: ${CMAKE_SYSTEM_PROCESSOR}" "sparc" "sparcv9") ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "^(parisc|hppa)") message(STATUS "System processor: parisc" "parisc64") ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "^s390") # s390 binaries can run on s390x machines message(STATUS "System processor: ${CMAKE_SYSTEM_PROCESSOR}" "s390" "s390x") ELSEIF(CMAKE_SYSTEM_PROCESSOR MATCHES "^sh") message(STATUS "System processor: sh") ELSE() #PROCESSOR NOT FOUND message(STATUS "PROCESSOR NOT FOUND: ${CMAKE_SYSTEM_PROCESSOR}") ENDIF() if(ARCH_32_BITS) set(MPI_ADDRESS_SIZE 4) else() set(MPI_ADDRESS_SIZE 8) endif() message(STATUS "Cmake version ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}") include(CheckFunctionExists) include(CheckTypeSize) include(CheckIncludeFile) include(CheckIncludeFiles) include(CheckLibraryExists) include(TestBigEndian) TEST_BIG_ENDIAN(BIGENDIAN) include(FindGraphviz) include(FindLibSigc++) set(HAVE_GTNETS 0) if(enable_gtnets) include(FindGTnets) endif() if(enable_java) find_package(Java REQUIRED COMPONENTS Runtime Development) find_package(JNI REQUIRED) message("-- [Java] JNI found: ${JNI_FOUND}") message("-- [Java] JNI include dirs: ${JNI_INCLUDE_DIRS}") if(enable_maintainer_mode) find_package(SWIG REQUIRED) include(UseSWIG) message("-- [Java] Swig found: ${SWIG_FOUND} (version ${SWIG_VERSION})") endif() set(HAVE_Java 1) endif() if(enable_scala) find_package(Scala REQUIRED) message("-- [Scala] scalac found: ${SCALA_COMPILE}") set(HAVE_Scala 1) endif() if(enable_lua) include(FindLua51Simgrid) endif() set(HAVE_NS3 0) if(enable_ns3) include(FindNS3) endif() find_package(Boost REQUIRED) if(Boost_FOUND) include_directories(${Boost_INCLUDE_DIRS}) else() message(FATAL_ERROR, "Failed to find Boost libraries") endif() # Checks for header libraries functions. CHECK_LIBRARY_EXISTS(dl dlopen "" HAVE_DLOPEN_IN_LIBDL) CHECK_LIBRARY_EXISTS(execinfo backtrace "" HAVE_BACKTRACE_IN_LIBEXECINFO) CHECK_LIBRARY_EXISTS(pthread pthread_create "" pthread) CHECK_LIBRARY_EXISTS(pthread sem_init "" HAVE_SEM_INIT_LIB) CHECK_LIBRARY_EXISTS(pthread sem_open "" HAVE_SEM_OPEN_LIB) CHECK_LIBRARY_EXISTS(pthread sem_timedwait "" HAVE_SEM_TIMEDWAIT_LIB) CHECK_LIBRARY_EXISTS(pthread pthread_mutex_timedlock "" HAVE_MUTEX_TIMEDLOCK_LIB) CHECK_LIBRARY_EXISTS(rt clock_gettime "" HAVE_POSIX_GETTIME) CHECK_INCLUDE_FILES("time.h;sys/time.h" TIME_WITH_SYS_TIME) CHECK_INCLUDE_FILES("stdlib.h;stdarg.h;string.h;float.h" STDC_HEADERS) CHECK_INCLUDE_FILE("pthread.h" HAVE_PTHREAD_H) CHECK_INCLUDE_FILE("valgrind/valgrind.h" HAVE_VALGRIND_VALGRIND_H) CHECK_INCLUDE_FILE("socket.h" HAVE_SOCKET_H) CHECK_INCLUDE_FILE("sys/socket.h" HAVE_SYS_SOCKET_H) CHECK_INCLUDE_FILE("stat.h" HAVE_STAT_H) CHECK_INCLUDE_FILE("sys/stat.h" HAVE_SYS_STAT_H) CHECK_INCLUDE_FILE("windows.h" HAVE_WINDOWS_H) CHECK_INCLUDE_FILE("winsock.h" HAVE_WINSOCK_H) CHECK_INCLUDE_FILE("winsock2.h" HAVE_WINSOCK2_H) CHECK_INCLUDE_FILE("WinDef.h" HAVE_WINDEF_H) CHECK_INCLUDE_FILE("errno.h" HAVE_ERRNO_H) CHECK_INCLUDE_FILE("unistd.h" HAVE_UNISTD_H) CHECK_INCLUDE_FILE("execinfo.h" HAVE_EXECINFO_H) CHECK_INCLUDE_FILE("signal.h" HAVE_SIGNAL_H) CHECK_INCLUDE_FILE("sys/time.h" HAVE_SYS_TIME_H) CHECK_INCLUDE_FILE("sys/param.h" HAVE_SYS_PARAM_H) CHECK_INCLUDE_FILE("sys/sysctl.h" HAVE_SYS_SYSCTL_H) CHECK_INCLUDE_FILE("time.h" HAVE_TIME_H) CHECK_INCLUDE_FILE("inttypes.h" HAVE_INTTYPES_H) CHECK_INCLUDE_FILE("memory.h" HAVE_MEMORY_H) CHECK_INCLUDE_FILE("stdlib.h" HAVE_STDLIB_H) CHECK_INCLUDE_FILE("strings.h" HAVE_STRINGS_H) CHECK_INCLUDE_FILE("string.h" HAVE_STRING_H) CHECK_INCLUDE_FILE("ucontext.h" HAVE_UCONTEXT_H) CHECK_INCLUDE_FILE("stdio.h" HAVE_STDIO_H) CHECK_INCLUDE_FILE("linux/futex.h" HAVE_FUTEX_H) CHECK_FUNCTION_EXISTS(gettimeofday HAVE_GETTIMEOFDAY) CHECK_FUNCTION_EXISTS(nanosleep HAVE_NANOSLEEP) CHECK_FUNCTION_EXISTS(getdtablesize HAVE_GETDTABLESIZE) CHECK_FUNCTION_EXISTS(sysconf HAVE_SYSCONF) CHECK_FUNCTION_EXISTS(readv HAVE_READV) CHECK_FUNCTION_EXISTS(popen HAVE_POPEN) CHECK_FUNCTION_EXISTS(signal HAVE_SIGNAL) CHECK_FUNCTION_EXISTS(snprintf HAVE_SNPRINTF) CHECK_FUNCTION_EXISTS(vsnprintf HAVE_VSNPRINTF) CHECK_FUNCTION_EXISTS(asprintf HAVE_ASPRINTF) CHECK_FUNCTION_EXISTS(vasprintf HAVE_VASPRINTF) CHECK_FUNCTION_EXISTS(makecontext HAVE_MAKECONTEXT) CHECK_FUNCTION_EXISTS(mmap HAVE_MMAP) #Check if __thread is defined execute_process( COMMAND "${CMAKE_C_COMPILER} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_thread_storage.c" WORKING_DIRECTORY ${CMAKE_BINARY_DIR} RESULT_VARIABLE HAVE_thread_storage_run ) if(HAVE_thread_storage_run) set(HAVE_THREAD_LOCAL_STORAGE 1) else() set(HAVE_THREAD_LOCAL_STORAGE 0) endif() # Our usage of mmap is Linux-specific (flag MAP_ANONYMOUS), but kFreeBSD uses a GNU libc IF(NOT "${CMAKE_SYSTEM}" MATCHES "Linux" AND NOT "${CMAKE_SYSTEM}" MATCHES "kFreeBSD" AND NOT "${CMAKE_SYSTEM}" MATCHES "GNU" AND NOT "${CMAKE_SYSTEM}" MATCHES "Darwin") SET(HAVE_MMAP 0) message(STATUS "Warning: MMAP is thought as non functional on this architecture (${CMAKE_SYSTEM})") ENDIF() if(HAVE_MMAP AND HAVE_THREAD_LOCAL_STORAGE) SET(HAVE_MMALLOC 1) else() SET(HAVE_MMALLOC 0) endif() if(WIN32) #THOSE FILES ARE FUNCTIONS ARE NOT DETECTED BUT THEY SHOULD... set(HAVE_UCONTEXT_H 1) set(HAVE_MAKECONTEXT 1) set(HAVE_SNPRINTF 1) set(HAVE_VSNPRINTF 1) endif() set(CONTEXT_UCONTEXT 0) SET(CONTEXT_THREADS 0) SET(HAVE_TRACING 1) if(enable_tracing) SET(HAVE_TRACING 1) else() SET(HAVE_TRACING 0) endif() if(enable_jedule) SET(HAVE_JEDULE 1) endif() if(enable_latency_bound_tracking) SET(HAVE_LATENCY_BOUND_TRACKING 1) else() if(enable_gtnets) message(STATUS "Warning : Turning latency_bound_tracking to ON because GTNeTs is ON") SET(enable_latency_bound_tracking ON) SET(HAVE_LATENCY_BOUND_TRACKING 1) else() SET(HAVE_LATENCY_BOUND_TRACKING 0) endif() endif() if(enable_mallocators) SET(MALLOCATOR_IS_WANTED 1) else() SET(MALLOCATOR_IS_WANTED 0) endif() if(enable_model-checking AND HAVE_MMALLOC) SET(HAVE_MC 1) SET(MMALLOC_WANT_OVERRIDE_LEGACY 1) include(FindLibunwind) include(FindLibdw) else() if(enable_model-checking) message(STATUS "Warning: support for model-checking has been disabled because HAVE_MMALLOC is false") endif() SET(HAVE_MC 0) SET(HAVE_MMALLOC 0) SET(MMALLOC_WANT_OVERRIDE_LEGACY 0) endif() if(enable_smpi) include(FindF2c) # FindGFortran must come after FindF2C, and after having set HAVE_MC include(FindGFortran) SET(HAVE_SMPI 1) endif() #-------------------------------------------------------------------------------------------------- ### Check for some architecture dependent values CHECK_TYPE_SIZE(int SIZEOF_INT) CHECK_TYPE_SIZE(void* SIZEOF_VOIDP) #-------------------------------------------------------------------------------------------------- ### Check for GNU dynamic linker CHECK_INCLUDE_FILE("dlfcn.h" HAVE_DLFCN_H) if (HAVE_DLFCN_H) if(HAVE_DLOPEN_IN_LIBDL) set(DL_LIBRARY "-ldl") endif(HAVE_DLOPEN_IN_LIBDL) execute_process(COMMAND ${CMAKE_C_COMPILER} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_gnu_dynlinker.c ${DL_LIBRARY} -o test_gnu_ld WORKING_DIRECTORY ${CMAKE_BINARY_DIR} OUTPUT_VARIABLE HAVE_GNU_LD_compil ) if(HAVE_GNU_LD_compil) set(HAVE_GNU_LD 0) message(STATUS "Warning: test program toward GNU ld failed to compile:") message(STATUS "${HAVE_GNU_LD_comp_output}") else() execute_process(COMMAND ./test_gnu_ld WORKING_DIRECTORY ${CMAKE_BINARY_DIR} RESULT_VARIABLE HAVE_GNU_LD_run OUTPUT_VARIABLE var_exec ) if(NOT HAVE_GNU_LD_run) set(HAVE_GNU_LD 1) message(STATUS "We are using GNU dynamic linker") else() set(HAVE_GNU_LD 0) message(STATUS "Warning: error while checking for GNU ld:") message(STATUS "Test output: '${var_exec}'") message(STATUS "Exit status: ${HAVE_GNU_LD_run}") endif() file(REMOVE test_gnu_ld) endif() endif() #-------------------------------------------------------------------------------------------------- ### Initialize of CONTEXT THREADS if(pthread) set(pthread 1) elseif(pthread) set(pthread 0) endif() if(pthread) ### Test that we have a way to create semaphores if(HAVE_SEM_OPEN_LIB) execute_process(COMMAND ${CMAKE_C_COMPILER} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_sem_open.c -lpthread -o sem_open WORKING_DIRECTORY ${CMAKE_BINARY_DIR} OUTPUT_VARIABLE HAVE_SEM_OPEN_compil ) if(HAVE_SEM_OPEN_compil) set(HAVE_SEM_OPEN 0) message(STATUS "Warning: sem_open not compilable") message(STATUS "HAVE_SEM_OPEN_comp_output: ${HAVE_SEM_OPEN_comp_output}") else() set(HAVE_SEM_OPEN 1) message(STATUS "sem_open is compilable") endif() execute_process(COMMAND ./sem_open WORKING_DIRECTORY ${CMAKE_BINARY_DIR} RESULT_VARIABLE HAVE_SEM_OPEN_run OUTPUT_VARIABLE var_compil ) file(REMOVE sem_open) if(NOT HAVE_SEM_OPEN_run) set(HAVE_SEM_OPEN 1) message(STATUS "sem_open is executable") else() set(HAVE_SEM_OPEN 0) if(EXISTS "${CMAKE_BINARY_DIR}/sem_open") message(STATUS "Bin ${CMAKE_BINARY_DIR}/sem_open exists!") else() message(STATUS "Bin ${CMAKE_BINARY_DIR}/sem_open not exists!") endif() message(STATUS "Warning: sem_open not executable") message(STATUS "Compilation output: '${var_compil}'") message(STATUS "Exit result of sem_open: ${HAVE_SEM_OPEN_run}") endif() else() set(HAVE_SEM_OPEN 0) endif() if(HAVE_SEM_INIT_LIB) execute_process(COMMAND ${CMAKE_C_COMPILER} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_sem_init.c -lpthread -o sem_init WORKING_DIRECTORY ${CMAKE_BINARY_DIR} RESULT_VARIABLE HAVE_SEM_INIT_run OUTPUT_VARIABLE HAVE_SEM_INIT_compil) if(HAVE_SEM_INIT_compil) set(HAVE_SEM_INIT 0) message(STATUS "Warning: sem_init not compilable") message(STATUS "HAVE_SEM_INIT_comp_output: ${HAVE_SEM_OPEN_comp_output}") else() set(HAVE_SEM_INIT 1) message(STATUS "sem_init is compilable") endif() execute_process(COMMAND ./sem_init WORKING_DIRECTORY ${CMAKE_BINARY_DIR} RESULT_VARIABLE HAVE_SEM_INIT_run OUTPUT_VARIABLE var_compil ) file(REMOVE sem_init) if(NOT HAVE_SEM_INIT_run) set(HAVE_SEM_INIT 1) message(STATUS "sem_init is executable") else() set(HAVE_SEM_INIT 0) if(EXISTS "${CMAKE_BINARY_DIR}/sem_init") message(STATUS "Bin ${CMAKE_BINARY_DIR}/sem_init exists!") else() message(STATUS "Bin ${CMAKE_BINARY_DIR}/sem_init not exists!") endif() message(STATUS "Warning: sem_init not executable") message(STATUS "Compilation output: '${var_compil}'") message(STATUS "Exit result of sem_init: ${HAVE_SEM_INIT_run}") endif() endif() if(NOT HAVE_SEM_OPEN AND NOT HAVE_SEM_INIT) message(FATAL_ERROR "Semaphores are not usable (neither sem_open nor sem_init is both compilable and executable), but they are mandatory to threads (you may need to mount /dev).") endif() ### Test that we have a way to timewait for semaphores if(HAVE_SEM_TIMEDWAIT_LIB) execute_process( COMMAND "${CMAKE_C_COMPILER} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_sem_timedwait.c -lpthread" WORKING_DIRECTORY ${CMAKE_BINARY_DIR} OUTPUT_VARIABLE HAVE_SEM_TIMEDWAIT_run ) if(HAVE_SEM_TIMEDWAIT_run) set(HAVE_SEM_TIMEDWAIT 0) message(STATUS "timedwait not compilable") else() set(HAVE_SEM_TIMEDWAIT 1) message(STATUS "timedwait is compilable") endif() endif() ### HAVE_MUTEX_TIMEDLOCK if(HAVE_MUTEX_TIMEDLOCK_LIB) execute_process( COMMAND "${CMAKE_C_COMPILER} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_mutex_timedlock.c -lpthread" WORKING_DIRECTORY ${CMAKE_BINARY_DIR} OUTPUT_VARIABLE HAVE_MUTEX_TIMEDLOCK_run ) if(HAVE_MUTEX_TIMEDLOCK_run) set(HAVE_MUTEX_TIMEDLOCK 0) message(STATUS "timedlock not compilable") else() message(STATUS "timedlock is compilable") set(HAVE_MUTEX_TIMEDLOCK 1) endif() endif() endif() # AC_CHECK_MCSC(mcsc=yes, mcsc=no) set(mcsc_flags "") if(CMAKE_SYSTEM_NAME MATCHES "Darwin") set(mcsc_flags -D_XOPEN_SOURCE) endif() if(WIN32) if(ARCH_32_BITS) set(mcsc_flags -D_XBT_WIN32 -D_I_X86_ -I${CMAKE_HOME_DIRECTORY}/src/include -I${CMAKE_HOME_DIRECTORY}/src/xbt) else() set(mcsc_flags -D_XBT_WIN32 -D_AMD64_ -I${CMAKE_HOME_DIRECTORY}/src/include -I${CMAKE_HOME_DIRECTORY}/src/xbt) endif() endif() IF(CMAKE_CROSSCOMPILING) IF(WIN32) set(windows_context "yes") set(IS_WINDOWS 1) ENDIF() ELSE() file(REMOVE "${CMAKE_BINARY_DIR}/testprog*") file(REMOVE ${CMAKE_BINARY_DIR}/conftestval) execute_process(COMMAND ${CMAKE_C_COMPILER} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_AC_CHECK_MCSC.c ${mcsc_flags} -o testprog WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/ OUTPUT_VARIABLE COMPILE_mcsc_VAR ERROR_VARIABLE COMPILE_mcsc_VAR) if(NOT COMPILE_mcsc_VAR) message(STATUS "prog_AC_CHECK_MCSC.c is compilable") execute_process(COMMAND ./testprog WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/ OUTPUT_VARIABLE var_compil) else() message(STATUS "prog_AC_CHECK_MCSC.c is not compilable:\n${COMPILE_mcsc_VAR}") endif() file(REMOVE "${CMAKE_BINARY_DIR}/testprog*") if(EXISTS "${CMAKE_BINARY_DIR}/conftestval") file(READ "${CMAKE_BINARY_DIR}/conftestval" mcsc) STRING(REPLACE "\n" "" mcsc "${mcsc}") if(mcsc) set(mcsc "yes") set(HAVE_UCONTEXT_H 1) else() set(mcsc "no") endif() else() set(mcsc "no") endif() message(STATUS "mcsc: ${mcsc}") ENDIF() if(mcsc MATCHES "no" AND pthread) if(HAVE_WINDOWS_H) set(windows_context "yes") set(IS_WINDOWS 1) elseif(HAVE_WINDOWS_H) message(FATAL_ERROR "no appropriate backend found") endif() endif() #Only windows if(WIN32) if(NOT HAVE_WINDOWS_H) message(FATAL_ERROR "no appropriate backend found windows") endif() endif() if(windows_context MATCHES "yes") message(STATUS "Context change to windows") endif() #If can have both context if(mcsc) set(CONTEXT_UCONTEXT 1) endif() if(pthread) set(CONTEXT_THREADS 1) endif() ############### ## GIT version check ## if(EXISTS ${CMAKE_HOME_DIRECTORY}/.git/) execute_process(COMMAND git remote COMMAND head -n 1 WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY}/.git/ OUTPUT_VARIABLE remote RESULT_VARIABLE ret ) string(REPLACE "\n" "" remote "${remote}") #message(STATUS "Git remote: ${remote}") execute_process(COMMAND git config --get remote.${remote}.url WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY}/.git/ OUTPUT_VARIABLE url RESULT_VARIABLE ret ) string(REPLACE "\n" "" url "${url}") #message(STATUS "Git url: ${url}") if(url) execute_process(COMMAND git --git-dir=${CMAKE_HOME_DIRECTORY}/.git log --pretty=oneline --abbrev-commit -1 WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY}/.git/ OUTPUT_VARIABLE GIT_VERSION RESULT_VARIABLE ret ) string(REPLACE "\n" "" GIT_VERSION "${GIT_VERSION}") message(STATUS "Git version: ${GIT_VERSION}") execute_process(COMMAND git --git-dir=${CMAKE_HOME_DIRECTORY}/.git log -n 1 --pretty=format:%ai . WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY}/.git/ OUTPUT_VARIABLE GIT_DATE RESULT_VARIABLE ret ) string(REPLACE "\n" "" GIT_DATE "${GIT_DATE}") message(STATUS "Git date: ${GIT_DATE}") string(REGEX REPLACE " .*" "" GIT_VERSION "${GIT_VERSION}") endif() elseif(EXISTS ${CMAKE_HOME_DIRECTORY}/.gitversion) FILE(STRINGS ${CMAKE_HOME_DIRECTORY}/.gitversion GIT_VERSION) endif() if(release) set(SIMGRID_VERSION_STRING "${SIMGRID_VERSION_STRING}\\nRelease build") else() set(SIMGRID_VERSION_STRING "${SIMGRID_VERSION_STRING}\\nDevelopment build") endif() if(GIT_VERSION) set(SIMGRID_VERSION_STRING "${SIMGRID_VERSION_STRING} at commit ${GIT_VERSION}") endif() if(GIT_DATE) set(SIMGRID_VERSION_STRING "${SIMGRID_VERSION_STRING} (${GIT_DATE})") endif() #-------------------------------------------------------------------------------------------------- set(makecontext_CPPFLAGS_2 "") if(HAVE_MAKECONTEXT OR WIN32) set(makecontext_CPPFLAGS "-DTEST_makecontext") if(CMAKE_SYSTEM_NAME MATCHES "Darwin") set(makecontext_CPPFLAGS_2 "-D_XOPEN_SOURCE") endif() if(WIN32) if(ARCH_32_BITS) set(makecontext_CPPFLAGS "-DTEST_makecontext -D_I_X86_") else() set(makecontext_CPPFLAGS "-DTEST_makecontext -D_AMD64_") endif() set(makecontext_CPPFLAGS_2 "-D_XBT_WIN32 -I${CMAKE_HOME_DIRECTORY}/src/include -I${CMAKE_HOME_DIRECTORY}/src/xbt") endif() file(REMOVE ${CMAKE_BINARY_DIR}/conftestval) try_run(RUN_makecontext_VAR COMPILE_makecontext_VAR ${CMAKE_BINARY_DIR} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_stacksetup.c COMPILE_DEFINITIONS "${makecontext_CPPFLAGS} ${makecontext_CPPFLAGS_2}" ) if(EXISTS ${CMAKE_BINARY_DIR}/conftestval) file(READ ${CMAKE_BINARY_DIR}/conftestval MAKECONTEXT_ADDR_SIZE) string(REPLACE "\n" "" MAKECONTEXT_ADDR_SIZE "${MAKECONTEXT_ADDR_SIZE}") string(REGEX MATCH ;^.*,;MAKECONTEXT_ADDR "${MAKECONTEXT_ADDR_SIZE}") string(REGEX MATCH ;,.*$; MAKECONTEXT_SIZE "${MAKECONTEXT_ADDR_SIZE}") string(REPLACE "," "" makecontext_addr "${MAKECONTEXT_ADDR}") string(REPLACE "," "" makecontext_size "${MAKECONTEXT_SIZE}") set(pth_skaddr_makecontext "#define pth_skaddr_makecontext(skaddr,sksize) (${makecontext_addr})") set(pth_sksize_makecontext "#define pth_sksize_makecontext(skaddr,sksize) (${makecontext_size})") message(STATUS "${pth_skaddr_makecontext}") message(STATUS "${pth_sksize_makecontext}") else() # message(FATAL_ERROR "makecontext is not compilable") endif() endif() #-------------------------------------------------------------------------------------------------- ### check for stackgrowth if (NOT CMAKE_CROSSCOMPILING) try_run(RUN_makecontext_VAR COMPILE_makecontext_VAR ${CMAKE_BINARY_DIR} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_stackgrowth.c ) file(READ "${CMAKE_BINARY_DIR}/conftestval" stack) if(stack MATCHES "down") set(PTH_STACKGROWTH "-1") endif() if(stack MATCHES "up") set(PTH_STACKGROWTH "1") endif() endif() ############### ## System checks ## #SG_CONFIGURE_PART([System checks...]) #AC_PROG_CC(xlC gcc cc) -auto #AM_SANITY_CHECK -auto #AC_PROG_MAKE_SET #AC_PRINTF_NULL FIXME: this is too ancient to survive! try_run(RUN_PRINTF_NULL_VAR COMPILE_PRINTF_NULL_VAR ${CMAKE_BINARY_DIR} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_printf_null.c ) if(RUN_PRINTF_NULL_VAR MATCHES "FAILED_TO_RUN") SET(PRINTF_NULL_WORKING "0") else() SET(PRINTF_NULL_WORKING "1") endif() #AC_CHECK_VA_COPY set(diff_va "va_copy((d),(s))" "VA_COPY((d),(s))" "__va_copy((d),(s))" "__builtin_va_copy((d),(s))" "do { (d) = (s)\; } while (0)" "do { *(d) = *(s)\; } while (0)" "memcpy((void *)&(d), (void *)&(s), sizeof(s))" "memcpy((void *)(d), (void *)(s), sizeof(*(s)))" ) foreach(fct ${diff_va}) write_file("${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_va_copy.c" "#include #include #include #define DO_VA_COPY(d,s) ${fct} void test(char *str, ...) { va_list ap, ap2; int i; va_start(ap, str); DO_VA_COPY(ap2, ap); for (i = 1; i <= 9; i++) { int k = (int)va_arg(ap, int); if (k != i) abort(); } DO_VA_COPY(ap, ap2); for (i = 1; i <= 9; i++) { int k = (int)va_arg(ap, int); if (k != i) abort(); } va_end(ap); } int main(void) { test(\"test\", 1, 2, 3, 4, 5, 6, 7, 8, 9); exit(0); }" ) execute_process( COMMAND ${CMAKE_C_COMPILER} "${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_va_copy.c" WORKING_DIRECTORY ${CMAKE_BINARY_DIR} RESULT_VARIABLE COMPILE_VA_NULL_VAR OUTPUT_QUIET ERROR_QUIET ) if(NOT COMPILE_VA_NULL_VAR) string(REGEX REPLACE "\;" "" fctbis ${fct}) if(${fctbis} STREQUAL "va_copy((d),(s))") set(HAVE_VA_COPY 1) set(ac_cv_va_copy "C99") set(__VA_COPY_USE_C99 "va_copy((d),(s))") endif() if(${fctbis} STREQUAL "VA_COPY((d),(s))") set(ac_cv_va_copy "GCM") set(__VA_COPY_USE_GCM "VA_COPY((d),(s))") endif() if(${fctbis} STREQUAL "__va_copy((d),(s))") set(ac_cv_va_copy "GCH") set(__VA_COPY_USE_GCH "__va_copy((d),(s))") endif() if(${fctbis} STREQUAL "__builtin_va_copy((d),(s))") set(ac_cv_va_copy "GCB") set(__VA_COPY_USE_GCB "__builtin_va_copy((d),(s))") endif() if(${fctbis} STREQUAL "do { (d) = (s) } while (0)") set(ac_cv_va_copy "ASS") set(__VA_COPY_USE_ASS "do { (d) = (s); } while (0)") endif() if(${fctbis} STREQUAL "do { *(d) = *(s) } while (0)") set(ac_cv_va_copy "ASP") set(__VA_COPY_USE_ASP "do { *(d) = *(s); } while (0)") endif() if(${fctbis} STREQUAL "memcpy((void *)&(d), (void *)&(s), sizeof(s))") set(ac_cv_va_copy "CPS") set(__VA_COPY_USE_CPS "memcpy((void *)&(d), (void *)&(s), sizeof(s))") endif() if(${fctbis} STREQUAL "memcpy((void *)(d), (void *)(s), sizeof(*(s)))") set(ac_cv_va_copy "CPP") set(__VA_COPY_USE_CPP "memcpy((void *)(d), (void *)(s), sizeof(*(s)))") endif() if(NOT STATUS_OK) set(__VA_COPY_USE "__VA_COPY_USE_${ac_cv_va_copy}(d, s)") endif() set(STATUS_OK "1") endif() endforeach(fct ${diff_va}) #-------------------------------------------------------------------------------------------------- ### check for a working snprintf if(HAVE_SNPRINTF AND HAVE_VSNPRINTF OR WIN32) if(WIN32) #set(HAVE_SNPRINTF 1) #set(HAVE_VSNPRINTF 1) endif() if(CMAKE_CROSSCOMPILING) set(RUN_SNPRINTF_FUNC "cross") #set(PREFER_PORTABLE_SNPRINTF 1) else() try_run(RUN_SNPRINTF_FUNC_VAR COMPILE_SNPRINTF_FUNC_VAR ${CMAKE_BINARY_DIR} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_snprintf.c ) endif() if(CMAKE_CROSSCOMPILING) set(RUN_VSNPRINTF_FUNC "cross") set(PREFER_PORTABLE_VSNPRINTF 1) else() try_run(RUN_VSNPRINTF_FUNC_VAR COMPILE_VSNPRINTF_FUNC_VAR ${CMAKE_BINARY_DIR} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_vsnprintf.c ) endif() set(PREFER_PORTABLE_SNPRINTF 0) if(RUN_VSNPRINTF_FUNC_VAR MATCHES "FAILED_TO_RUN") set(PREFER_PORTABLE_SNPRINTF 1) endif() if(RUN_SNPRINTF_FUNC_VAR MATCHES "FAILED_TO_RUN") set(PREFER_PORTABLE_SNPRINTF 1) endif() endif() ### check for asprintf function familly if(HAVE_ASPRINTF) SET(simgrid_need_asprintf "") SET(NEED_ASPRINTF 0) else() SET(simgrid_need_asprintf "#define SIMGRID_NEED_ASPRINTF 1") SET(NEED_ASPRINTF 1) endif() if(HAVE_VASPRINTF) SET(simgrid_need_vasprintf "") SET(NEED_VASPRINTF 0) else() SET(simgrid_need_vasprintf "#define SIMGRID_NEED_VASPRINTF 1") SET(NEED_VASPRINTF 1) endif() ### check for addr2line find_path(ADDR2LINE NAMES addr2line PATHS NO_DEFAULT_PATHS ) if(ADDR2LINE) set(ADDR2LINE "${ADDR2LINE}/addr2line") endif() ### Check if OSX can compile with ucontext (with gcc 4.[1-5] it is broken) if(APPLE) if(APPLE_NEED_GCC_VERSION GREATER COMPILER_C_VERSION_MAJOR_MINOR) message(STATUS "Ucontext can't be used with this version of gcc (must be greater than 4.5)") set(HAVE_UCONTEXT_H 0) endif() endif() ### File to create configure_file("${CMAKE_HOME_DIRECTORY}/src/context_sysv_config.h.in" "${CMAKE_BINARY_DIR}/src/context_sysv_config.h" @ONLY IMMEDIATE) SET( CMAKEDEFINE "#cmakedefine" ) configure_file("${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/src/internal_config.h.in" "${CMAKE_BINARY_DIR}/src/internal_config.h" @ONLY IMMEDIATE) configure_file("${CMAKE_BINARY_DIR}/src/internal_config.h" "${CMAKE_BINARY_DIR}/src/internal_config.h" @ONLY IMMEDIATE) configure_file("${CMAKE_HOME_DIRECTORY}/include/simgrid_config.h.in" "${CMAKE_BINARY_DIR}/include/simgrid_config.h" @ONLY IMMEDIATE) set(top_srcdir "${CMAKE_HOME_DIRECTORY}") set(srcdir "${CMAKE_HOME_DIRECTORY}/src") set(bindir "${CMAKE_BINARY_DIR}") ### Script used when simgrid is installed set(exec_prefix ${CMAKE_INSTALL_PREFIX}) set(includeflag "-I${CMAKE_INSTALL_PREFIX}/include -I${CMAKE_INSTALL_PREFIX}/include/smpi") set(includedir "${CMAKE_INSTALL_PREFIX}/include") set(libdir ${exec_prefix}/lib) set(CMAKE_SMPI_COMMAND "export LD_LIBRARY_PATH=\"${CMAKE_INSTALL_PREFIX}/lib") if(GTNETS_LIB_PATH) set(CMAKE_SMPI_COMMAND "${CMAKE_SMPI_COMMAND}:${GTNETS_LIB_PATH}") endif() if(HAVE_NS3_LIB) set(CMAKE_SMPI_COMMAND "${CMAKE_SMPI_COMMAND}:${HAVE_NS3_LIB}") endif() set(CMAKE_SMPI_COMMAND "${CMAKE_SMPI_COMMAND}:\${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}\"") file(READ ${CMAKE_HOME_DIRECTORY}/src/smpi/smpitools.sh SMPITOOLS_SH) configure_file(${CMAKE_HOME_DIRECTORY}/include/smpi/mpif.h.in ${CMAKE_BINARY_DIR}/include/smpi/mpif.h @ONLY) configure_file(${CMAKE_HOME_DIRECTORY}/include/smpi/smpif.h.in ${CMAKE_BINARY_DIR}/include/smpi/smpif.h @ONLY) configure_file(${CMAKE_HOME_DIRECTORY}/src/smpi/smpicc.in ${CMAKE_BINARY_DIR}/bin/smpicc @ONLY) configure_file(${CMAKE_HOME_DIRECTORY}/src/smpi/smpicxx.in ${CMAKE_BINARY_DIR}/bin/smpicxx @ONLY) configure_file(${CMAKE_HOME_DIRECTORY}/src/smpi/smpif2c.in ${CMAKE_BINARY_DIR}/bin/smpif2c @ONLY) configure_file(${CMAKE_HOME_DIRECTORY}/src/smpi/smpiff.in ${CMAKE_BINARY_DIR}/bin/smpiff @ONLY) configure_file(${CMAKE_HOME_DIRECTORY}/src/smpi/smpif90.in ${CMAKE_BINARY_DIR}/bin/smpif90 @ONLY) configure_file(${CMAKE_HOME_DIRECTORY}/src/smpi/smpirun.in ${CMAKE_BINARY_DIR}/bin/smpirun @ONLY) ### Script used when simgrid is compiling set(includeflag "-I${CMAKE_HOME_DIRECTORY}/include -I${CMAKE_HOME_DIRECTORY}/include/smpi") set(includeflag "${includeflag} -I${CMAKE_BINARY_DIR}/include -I${CMAKE_BINARY_DIR}/include/smpi") set(includedir "${CMAKE_HOME_DIRECTORY}/include") set(exec_prefix "${CMAKE_BINARY_DIR}/smpi_script/") set(CMAKE_SMPI_COMMAND "export LD_LIBRARY_PATH=\"${CMAKE_BINARY_DIR}/lib") if(GTNETS_LIB_PATH) set(CMAKE_SMPI_COMMAND "${CMAKE_SMPI_COMMAND}:${GTNETS_LIB_PATH}") endif() if(HAVE_NS3_LIB) set(CMAKE_SMPI_COMMAND "${CMAKE_SMPI_COMMAND}:${HAVE_NS3_LIB}") endif() set(CMAKE_SMPI_COMMAND "${CMAKE_SMPI_COMMAND}:\${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}\"") set(libdir "${CMAKE_BINARY_DIR}/lib") configure_file(${CMAKE_HOME_DIRECTORY}/src/smpi/smpicc.in ${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc @ONLY) configure_file(${CMAKE_HOME_DIRECTORY}/src/smpi/smpicxx.in ${CMAKE_BINARY_DIR}/smpi_script/bin/smpicxx @ONLY) configure_file(${CMAKE_HOME_DIRECTORY}/src/smpi/smpif2c.in ${CMAKE_BINARY_DIR}/smpi_script/bin/smpif2c @ONLY) configure_file(${CMAKE_HOME_DIRECTORY}/src/smpi/smpiff.in ${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff @ONLY) configure_file(${CMAKE_HOME_DIRECTORY}/src/smpi/smpif90.in ${CMAKE_BINARY_DIR}/smpi_script/bin/smpif90 @ONLY) configure_file(${CMAKE_HOME_DIRECTORY}/src/smpi/smpirun.in ${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun @ONLY) set(top_builddir ${CMAKE_HOME_DIRECTORY}) if(NOT WIN32) execute_process(COMMAND chmod a=rwx ${CMAKE_BINARY_DIR}/bin/smpicc) execute_process(COMMAND chmod a=rwx ${CMAKE_BINARY_DIR}/bin/smpicxx) execute_process(COMMAND chmod a=rwx ${CMAKE_BINARY_DIR}/bin/smpif2c) execute_process(COMMAND chmod a=rwx ${CMAKE_BINARY_DIR}/bin/smpiff) execute_process(COMMAND chmod a=rwx ${CMAKE_BINARY_DIR}/bin/smpif90) execute_process(COMMAND chmod a=rwx ${CMAKE_BINARY_DIR}/bin/smpirun) execute_process(COMMAND chmod a=rwx ${CMAKE_BINARY_DIR}/smpi_script/bin/smpicc) execute_process(COMMAND chmod a=rwx ${CMAKE_BINARY_DIR}/smpi_script/bin/smpicxx) execute_process(COMMAND chmod a=rwx ${CMAKE_BINARY_DIR}/smpi_script/bin/smpif2c) execute_process(COMMAND chmod a=rwx ${CMAKE_BINARY_DIR}/smpi_script/bin/smpiff) execute_process(COMMAND chmod a=rwx ${CMAKE_BINARY_DIR}/smpi_script/bin/smpif90) execute_process(COMMAND chmod a=rwx ${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun) endif() set(generated_headers_to_install ${CMAKE_CURRENT_BINARY_DIR}/include/smpi/mpif.h ${CMAKE_CURRENT_BINARY_DIR}/include/smpi/smpif.h ${CMAKE_CURRENT_BINARY_DIR}/include/simgrid_config.h ) set(generated_headers ${CMAKE_CURRENT_BINARY_DIR}/src/context_sysv_config.h ${CMAKE_CURRENT_BINARY_DIR}/src/internal_config.h ) set(generated_files_to_clean ${generated_headers} ${generated_headers_to_install} ${CMAKE_BINARY_DIR}/bin/smpicc ${CMAKE_BINARY_DIR}/bin/smpicxx ${CMAKE_BINARY_DIR}/bin/smpif2c ${CMAKE_BINARY_DIR}/bin/smpiff ${CMAKE_BINARY_DIR}/bin/smpif90 ${CMAKE_BINARY_DIR}/bin/smpirun ${CMAKE_BINARY_DIR}/bin/colorize ${CMAKE_BINARY_DIR}/bin/simgrid_update_xml ${CMAKE_BINARY_DIR}/examples/smpi/tracing/smpi_traced.trace ) if("${CMAKE_BINARY_DIR}" STREQUAL "${CMAKE_HOME_DIRECTORY}") else() configure_file(${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/actions0.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions0.txt COPYONLY) configure_file(${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/actions1.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions1.txt COPYONLY) configure_file(${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/actions_allReduce.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_allReduce.txt COPYONLY) configure_file(${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/actions_barrier.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_barrier.txt COPYONLY) configure_file(${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/actions_bcast.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_bcast.txt COPYONLY) configure_file(${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/actions_with_isend.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_with_isend.txt COPYONLY) configure_file(${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/actions_alltoall.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_alltoall.txt COPYONLY) configure_file(${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/actions_alltoallv.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_alltoallv.txt COPYONLY) configure_file(${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/actions_waitall.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_waitall.txt COPYONLY) configure_file(${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/actions_reducescatter.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_reducescatter.txt COPYONLY) configure_file(${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/actions_gather.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_gather.txt COPYONLY) configure_file(${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/actions_allgatherv.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_allgatherv.txt COPYONLY) configure_file(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/hostfile ${CMAKE_BINARY_DIR}/teshsuite/smpi/hostfile COPYONLY) set(generated_files_to_clean ${generated_files_to_clean} ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions0.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions1.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_allReduce.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_barrier.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_bcast.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_with_isend.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_alltoall.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_alltoallv.txt ${CMAKE_BINARY_DIR}/examples/smpi/replay/actions_waitall.txt ${CMAKE_BINARY_DIR}/teshsuite/smpi/hostfile ) endif() SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${generated_files_to_clean}") IF(${ARCH_32_BITS}) set(WIN_ARCH "32") ELSE() set(WIN_ARCH "64") ENDIF() configure_file("${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/src/simgrid.nsi.in" "${CMAKE_BINARY_DIR}/simgrid.nsi" @ONLY IMMEDIATE) SimGrid-3.11/buildtools/Cmake/Pipol.cmake000644 001750 001750 00000013412 12342443653 017320 0ustar00cici000000 000000 # On a Pipol system, set: # PIPOL_USER #SET(PIPOL_USER $ENV{PIPOL_USER}) # ssh/rsync mandatory IF(pipol_user) set(CMAKE_OPTIONS " -Wno-dev") if(with_context) set(CMAKE_OPTIONS "${CMAKE_OPTIONS} -Dwith_context=${with_context}") endif() if(enable_smpi) set(CMAKE_OPTIONS "${CMAKE_OPTIONS} -Denable_smpi=on") set(CMAKE_OPTIONS "${CMAKE_OPTIONS} -Denable_smpi_MPICH3_testsuite=on") endif() if(enable_lua) set(CMAKE_OPTIONS "${CMAKE_OPTIONS} -Denable_lua=on") endif() if(enable_compile_optimizations) set(CMAKE_OPTIONS "${CMAKE_OPTIONS} -Denable_compile_optimizations=on") endif() if(enable_compile_warnings) set(CMAKE_OPTIONS "${CMAKE_OPTIONS} -Denable_compile_warnings=on") endif() if(enable_tracing) set(CMAKE_OPTIONS "${CMAKE_OPTIONS} -Denable_tracing=on") endif() if(enable_coverage) set(CMAKE_OPTIONS "${CMAKE_OPTION} -Denable_coverage=on") endif() if(enable_print_message) set(CMAKE_OPTIONS "${CMAKE_OPTIONS} -Denable_print_message=on") endif() if(enable_model-checking) set(CMAKE_OPTIONS "${CMAKE_OPTIONS} -Denable_model-checking=on") endif() if(enable_latency_bound_tracking) set(CMAKE_OPTIONS "${CMAKE_OPTIONS} -Denable_latency_bound_tracking=on") endif() FIND_PROGRAM(HAVE_SSH ssh) FIND_PROGRAM(HAVE_RSYNC rsync) MESSAGE(STATUS "Pipol user is '${pipol_user}'") IF(HAVE_SSH) message(STATUS "Found ssh: ${HAVE_SSH}") # get pipol systems EXECUTE_PROCESS(COMMAND ssh ${pipol_user}@pipol.inria.fr pipol-sub --query=systems OUTPUT_VARIABLE PIPOL_SYSTEMS OUTPUT_STRIP_TRAILING_WHITESPACE) ENDIF() ADD_CUSTOM_TARGET(pipol_test_list_images COMMENT "Available images for pipol tests (cmake + make + make test) : " ) ADD_CUSTOM_TARGET(pipol_experimental_list_images COMMENT "Available images for ctest (ctest -D Experimental) : " ) ADD_CUSTOM_TARGET(pipol_kvm_deploy COMMENT "Deploy all kvm images on pipol (ctest -D Experimental) : " ) ADD_CUSTOM_COMMAND(TARGET pipol_kvm_deploy POST_BUILD COMMENT "See results on http://cdash.inria.fr/CDash/index.php?project=Simgrid" ) IF(HAVE_RSYNC) message(STATUS "Found rsync: ${HAVE_RSYNC}") MACRO(PIPOL_TARGET SYSTEM_PATTERN) STRING(REPLACE ".dd.gz" "" SYSTEM_TARGET ${SYSTEM_PATTERN}) ADD_CUSTOM_TARGET( ${SYSTEM_TARGET} COMMENT "PIPOL Build : ${SYSTEM_PATTERN}" COMMAND rsync ${pipol_user}@pipol.inria.fr:/usr/local/bin/pipol-sub . COMMAND ./pipol-sub --pipol-user=${pipol_user} ${SYSTEM_PATTERN} 02:00 --reconnect --group --keep --verbose=1 --export=${CMAKE_HOME_DIRECTORY} --rsynco=-aC \"sudo chown ${pipol_user} ${CMAKE_HOME_DIRECTORY} \; cd ${CMAKE_HOME_DIRECTORY} \; sh ${CMAKE_HOME_DIRECTORY}/buildtools/pipol/liste_install.sh \; cmake -E remove CMakeCache.txt \; cmake ${CMAKE_HOME_DIRECTORY}${CMAKE_OPTIONS} \; make clean \; make \; make check \" ) ADD_CUSTOM_TARGET( ${SYSTEM_TARGET}_experimental COMMENT "PIPOL Build : ${SYSTEM_PATTERN}_experimental" COMMAND rsync ${pipol_user}@pipol.inria.fr:/usr/local/bin/pipol-sub . COMMAND ./pipol-sub --pipol-user=${pipol_user} ${SYSTEM_PATTERN} 02:00 --reconnect --group --keep --verbose=1 --export=${CMAKE_HOME_DIRECTORY} --rsynco=-aC \"sudo chown ${pipol_user} ${CMAKE_HOME_DIRECTORY} \; cd ${CMAKE_HOME_DIRECTORY} \; sh ${CMAKE_HOME_DIRECTORY}/buildtools/pipol/liste_install.sh \; cmake -E remove CMakeCache.txt \; cmake ${CMAKE_HOME_DIRECTORY}${CMAKE_OPTIONS} \; ctest -D Experimental \" ) STRING(REGEX MATCH "kvm" make_test "${SYSTEM_TARGET}") if(make_test) STRING(REGEX MATCH "windows" make_test "${SYSTEM_TARGET}") if(NOT make_test) ADD_CUSTOM_COMMAND(TARGET pipol_kvm_deploy COMMENT "PIPOL Build : ${SYSTEM_PATTERN}" COMMAND rsync ${pipol_user}@pipol.inria.fr:/usr/local/bin/pipol-sub . COMMAND ./pipol-sub --pipol-user=${pipol_user} ${SYSTEM_PATTERN} 02:00 --reconnect --group --keep --verbose=1 --export=${CMAKE_HOME_DIRECTORY} --rsynco=-aC \"sudo chown ${pipol_user} ${CMAKE_HOME_DIRECTORY} \; cd ${CMAKE_HOME_DIRECTORY} \; sh ${CMAKE_HOME_DIRECTORY}/buildtools/pipol/liste_install.sh \; cmake -E remove CMakeCache.txt \; cmake ${CMAKE_HOME_DIRECTORY}${CMAKE_OPTIONS} \; ctest -D Experimental \" ) endif() endif() ADD_CUSTOM_COMMAND(TARGET ${SYSTEM_TARGET}_experimental POST_BUILD COMMENT "See results on http://cdash.inria.fr/CDash/index.php?project=Simgrid" ) ADD_CUSTOM_COMMAND(TARGET pipol_test_list_images COMMAND echo ${SYSTEM_TARGET} ) ADD_CUSTOM_COMMAND(TARGET pipol_experimental_list_images COMMAND echo "${SYSTEM_TARGET}_experimental" ) ENDMACRO(PIPOL_TARGET) ENDIF() # add a target for each pipol system IF(PIPOL_SYSTEMS) #MESSAGE(STATUS "Adding Pipol targets") FOREACH(SYSTEM ${PIPOL_SYSTEMS}) PIPOL_TARGET(${SYSTEM}) ENDFOREACH(SYSTEM ${PIPOL_SYSTEMS}) ENDIF() ADD_CUSTOM_TARGET(pipol_kill_all_jobs COMMENT "PIPOL delete all jobs" COMMAND ./pipol-sub --pipol-user=${pipol_user} deleteallmyjobs ) #message(STATUS "Pipol options: ${CMAKE_OPTIONS}") add_custom_target(sync-pipol COMMENT "Update pipol script for user: ${pipol_user}" COMMAND scp ${CMAKE_HOME_DIRECTORY}/buildtools/pipol/rc.* ${pipol_user}@pipol.inria.fr:~/.pipol/ COMMAND scp ${CMAKE_HOME_DIRECTORY}/buildtools/pipol/Nightly_simgrid.sh ${pipol_user}@pipol.inria.fr:~/.pipol/nightly/ COMMAND scp ${CMAKE_HOME_DIRECTORY}/buildtools/pipol/Nightly_memCheck.sh ${pipol_user}@pipol.inria.fr:~/.pipol/nightly/ COMMAND scp ${CMAKE_HOME_DIRECTORY}/buildtools/pipol/Experimental_bindings.sh ${pipol_user}@pipol.inria.fr:~/ COMMAND scp ${CMAKE_HOME_DIRECTORY}/buildtools/pipol/pre-simgrid.sh ${pipol_user}@pipol.inria.fr:~/ COMMAND ssh ${pipol_user}@pipol.inria.fr "chmod a=rwx ~/* ~/.pipol/rc.* ~/.pipol/nightly/*" ) ENDIF() SimGrid-3.11/buildtools/Cmake/Option.cmake000644 001750 001750 00000007370 12342443653 017513 0ustar00cici000000 000000 ### ARGs use -D[var]=[ON/OFF] or [1/0] or [true/false](see after) ### ex: cmake -Denable_java=ON -Denable_gtnets=ON ./ set(BIBTEX2HTML ${BIBTEX2HTML} CACHE PATH "Path to bibtex2html") set(gtnets_path ${gtnets_path} CACHE PATH "Path to gtnets lib and include") set(ns3_path ${ns3_path} CACHE PATH "Path to ns3 lib and include") if(NOT CMAKE_INSTALL_PREFIX) set(CMAKE_INSTALL_PREFIX "/usr/local/simgrid/" CACHE PATH "Path where to install project") else() set(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX} CACHE PATH "Path where to install project") endif() set(pipol_user ${pipol_user} CACHE TYPE INTERNAL FORCE) mark_as_advanced(pipol_user) option(release "Whether Release Mode is activated (disable tests on experimental parts)" on) option(enable_compile_optimizations "Whether to produce efficient code for the SimGrid library" on) option(enable_gtnets "Whether gtnets model is activated." off) option(enable_ns3 "Whether ns3 model is activated." off) option(enable_java "Whether the Java bindings are activated." off) option(enable_scala "Whether the Scala bindings are activated." off) option(enable_lua "Whether the lua bindings are activated." off) option(enable_compile_warnings "Whether compilation warnings should be turned into errors." off) option(enable_maintainer_mode "Whether flex and flexml files should be rebuilt." off) option(enable_tracing "Tracing simulations for visualization." on) option(enable_latency_bound_tracking "" off) option(enable_coverage "Enable coverage." off) mark_as_advanced(enable_coverage) option(enable_memcheck "Enable memcheck." off) option(enable_memcheck_xml "Enable memcheck with xml output." off) mark_as_advanced(enable_memcheck) mark_as_advanced(enable_memcheck_xml) option(enable_mallocators "Enable mallocators (disable only for debugging purpose)." on) option(enable_print_message "Enable print message during config." off) mark_as_advanced(enable_print_message) option(enable_model-checking "Turn this on to experiment with our prototype of model-checker (hinders the simulation's performance even if turned of at runtime)" off) option(enable_lib_static "" off) option(enable_lib_in_jar "Whether the native libraries are bundled into the Java jar file" on) option(enable_jedule "Jedule output of SimDAG." off) option(enable_debug "Turn this off to remove all debug messages at compile time (faster, but no debug activable)" on) option(enable_msg_deprecated "This option enable the use of msg deprecated functions" off) if(WIN32) option(enable_smpi "Whether SMPI in included in library." off) option(enable_smpi_MPICH3_testsuite "Whether the test suite form MPICH 3 should be built" off) else() option(enable_smpi "Whether SMPI in included in library." on) option(enable_smpi_MPICH3_testsuite "Whether the test suite form MPICH 3 should be built" off) endif() if(enable_scala AND NOT enable_java) message(WARNING "For using scala you must turn java on with command:\ncmake -Denable_java=on .") endif() mark_as_advanced(HAVE_SSH) mark_as_advanced(HAVE_RSYNC) mark_as_advanced(BIBTEX2HTML_PATH) mark_as_advanced(BUILDNAME) mark_as_advanced(ADDR2LINE) mark_as_advanced(BIBTOOL_PATH) mark_as_advanced(BUILD_TESTING) mark_as_advanced(CMAKE_BUILD_TYPE) mark_as_advanced(DART_ROOT) mark_as_advanced(DOXYGEN_PATH) mark_as_advanced(FIG2DEV_PATH) mark_as_advanced(FLEXML_EXE) mark_as_advanced(FLEX_EXE) mark_as_advanced(PERL_EXECUTABLE) mark_as_advanced(GCOV_PATH) mark_as_advanced(ICONV_PATH) mark_as_advanced(MAKE_PATH) mark_as_advanced(SVN) mark_as_advanced(GIT) mark_as_advanced(CMAKE_OSX_ARCHITECTURES) mark_as_advanced(CMAKE_OSX_DEPLOYMENT_TARGET) mark_as_advanced(CMAKE_OSX_SYSROOT) mark_as_advanced(SED_EXE) mark_as_advanced(BIBTEX2HTML) mark_as_advanced(CMAKE_C_LINK_FLAGS) mark_as_advanced(CMAKE_CXX_FLAGS) mark_as_advanced(CMAKE_Fortran_LINK_FLAGS) SimGrid-3.11/buildtools/Cmake/MaintainerMode.cmake000644 001750 001750 00000030651 12342443653 021135 0ustar00cici000000 000000 # Change the following when we need a recent enough version of flexml to get the maintainer mode working set(FLEXML_MIN_MAJOR 1) set(FLEXML_MIN_MINOR 9) set(FLEXML_MIN_PATCH 6) # the rest should only be changed if you understand what you're doing if(enable_maintainer_mode AND NOT WIN32) find_program(PYTHON_EXE NAMES python) mark_as_advanced(PYTHON_EXE) if (PYTHON_EXE) add_custom_command( OUTPUT ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_enum.h ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_string.c ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_res_getter_setter.h ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_args_getter_setter.h ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_case.c ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_body.c DEPENDS ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls.py ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls.in COMMENT "Generating simcalls source files" COMMAND ${PYTHON_EXE} simcalls.py WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY}/src/simix/ ) add_custom_target(simcalls_generated_src DEPENDS ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_enum.h ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_string.c ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_res_getter_setter.h ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_args_getter_setter.h ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_case.c ${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_body.c ) SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_enum.h;${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_string.c;${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_res_getter_setter.h;${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_args_getter_setter.h;${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_case.c;${CMAKE_HOME_DIRECTORY}/src/simix/simcalls_generated_body.c" ) endif() endif() if(enable_maintainer_mode AND NOT WIN32) find_program(FLEX_EXE NAMES flex) find_program(FLEXML_EXE NAMES flexml) find_program(SED_EXE NAMES sed) find_program(BISON_EXE NAMES bison) find_program(LEX_EXE NAMES lex) mark_as_advanced(BISON_EXE) mark_as_advanced(LEX_EXE) if(BISON_EXE AND LEX_EXE) add_custom_command( OUTPUT ${CMAKE_HOME_DIRECTORY}/src/xbt/automaton/automaton_lexer.yy.c ${CMAKE_HOME_DIRECTORY}/src/xbt/automaton/parserPromela.tab.cacc ${CMAKE_HOME_DIRECTORY}/src/xbt/automaton/parserPromela.tab.hacc DEPENDS ${CMAKE_HOME_DIRECTORY}/src/xbt/automaton/parserPromela.lex ${CMAKE_HOME_DIRECTORY}/src/xbt/automaton/parserPromela.yacc COMMENT "Generating automaton source files" COMMAND ${BISON_EXE} --name-prefix=xbt_automaton_parser_ -d parserPromela.yacc COMMAND ${LEX_EXE} --prefix=xbt_automaton_parser_ --outfile=automaton_lexer.yy.c parserPromela.lex WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY}/src/xbt/automaton/ ) add_custom_target(automaton_generated_src DEPENDS ${CMAKE_HOME_DIRECTORY}/src/xbt/automaton/automaton_lexer.yy.c ${CMAKE_HOME_DIRECTORY}/src/xbt/automaton/parserPromela.tab.cacc ${CMAKE_HOME_DIRECTORY}/src/xbt/automaton/parserPromela.tab.hacc ) SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${CMAKE_HOME_DIRECTORY}/src/xbt/automaton/parserPromela.tab.cacc;${CMAKE_HOME_DIRECTORY}/src/xbt/automaton/parserPromela.tab.hacc;${CMAKE_HOME_DIRECTORY}/src/xbt/automaton/automaton_parse.yy.c" ) endif() IF(FLEX_EXE) set(HAVE_FLEX 1) exec_program("${FLEX_EXE} --version" OUTPUT_VARIABLE FLEX_VERSION) string(REGEX MATCH "[0-9]+[.]+[0-9]+[.]+[0-9]+" FLEX_VERSION "${FLEX_VERSION}") string(REGEX MATCH "^[0-9]+" FLEX_MAJOR_VERSION "${FLEX_VERSION}") string(REGEX MATCH "[0-9]+[.]+[0-9]+$" FLEX_VERSION "${FLEX_VERSION}") string(REGEX MATCH "^[0-9]+" FLEX_MINOR_VERSION "${FLEX_VERSION}") string(REGEX MATCH "[0-9]+$" FLEX_PATCH_VERSION "${FLEX_VERSION}") ENDIF() IF(FLEXML_EXE) set(HAVE_FLEXML 1) exec_program("${FLEXML_EXE} --version" OUTPUT_VARIABLE FLEXML_VERSION) if (FLEXML_VERSION MATCHES "version Id:") message(FATAL_ERROR "You have an ancient flexml version (${FLEXML_VERSION}). You need at least v${FLEXML_MIN_MAJOR}.${FLEXML_MIN_MINOR}.${FLEXML_MIN_PATCH} to compile in maintainer mode. Upgrade your flexml, or disable the Maintainer mode option in cmake.") endif() string(REGEX MATCH "[0-9]+[.]+[0-9]+[.]+[0-9]+" FLEXML_VERSION "${FLEXML_VERSION}") string(REGEX MATCH "^[0-9]*" FLEXML_MAJOR_VERSION "${FLEXML_VERSION}") string(REGEX MATCH "[0-9]+[.]+[0-9]+$" FLEXML_VERSION "${FLEXML_VERSION}") string(REGEX MATCH "^[0-9]+" FLEXML_MINOR_VERSION "${FLEXML_VERSION}") string(REGEX MATCH "[0-9]+$" FLEXML_PATCH_VERSION "${FLEXML_VERSION}") ENDIF() message(STATUS "Found flex: ${FLEX_EXE}") message(STATUS "Found flexml: ${FLEXML_EXE}") message(STATUS "Found sed: ${SED_EXE}") if(HAVE_FLEXML AND HAVE_FLEX AND SED_EXE) message(STATUS "Flex version: ${FLEX_MAJOR_VERSION}.${FLEX_MINOR_VERSION}.${FLEX_PATCH_VERSION}") message(STATUS "Flexml version: ${FLEXML_MAJOR_VERSION}.${FLEXML_MINOR_VERSION}.${FLEXML_PATCH_VERSION} (need at least version ${FLEXML_MIN_MAJOR}.${FLEXML_MIN_MINOR}.${FLEXML_MIN_PATCH})") IF( (${FLEXML_MAJOR_VERSION} LESS ${FLEXML_MIN_MAJOR}) OR ((${FLEXML_MAJOR_VERSION} EQUAL ${FLEXML_MIN_MAJOR}) AND (${FLEXML_MINOR_VERSION} LESS ${FLEXML_MIN_MINOR}) ) OR ( (${FLEXML_MAJOR_VERSION} EQUAL ${FLEXML_MIN_MAJOR}) AND (${FLEXML_MINOR_VERSION} EQUAL ${FLEXML_MIN_MINOR}) AND (${FLEXML_PATCH_VERSION} LESS ${FLEXML_MIN_PATCH}) )) message(FATAL_ERROR "Your flexml version is too old to compile in maintainer mode (need at least v${FLEXML_MIN_MAJOR}.${FLEXML_MIN_MINOR}.${FLEXML_MIN_PATCH}). Upgrade your flexml, or disable the Maintainer mode option in cmake.") ENDIF() set(string1 "'s/extern *\\([^(]*\\)\\( \\|\\( \\*\\)\\)/XBT_PUBLIC_DATA(\\1\\3) /'") set(string2 "'s/XBT_PUBLIC_DATA(\\([^)]*\\)) *\\([^(]*\\)(/XBT_PUBLIC(\\1) \\2(/'") set(string5 "'s/SET(DOCTYPE)/SET(ROOT_dax__adag)/'") set(string8 "'s/#if defined(_WIN32)/#if defined(_XBT_WIN32)/g'") set(string9 "'s/#include /#if defined(_XBT_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__TOS_WIN__)\\n# ifndef __STRICT_ANSI__\\n# include \\n# include \\n# endif\\n#else\\n# include \\n#endif/g'") set(string14 "'\\!^ \\* Generated [0-9/]\\{10\\} [0-9:]\\{8\\}\\.$$!d'") set(string15 "'s/FAIL(\"Premature EOF/if(!ETag_surfxml_include_state()) FAIL(\"Premature EOF/'") ADD_CUSTOM_COMMAND( OUTPUT ${CMAKE_HOME_DIRECTORY}/include/surf/simgrid_dtd.h ${CMAKE_HOME_DIRECTORY}/include/xbt/graphxml.h ${CMAKE_HOME_DIRECTORY}/src/simdag/dax_dtd.h ${CMAKE_HOME_DIRECTORY}/src/surf/simgrid_dtd.c ${CMAKE_HOME_DIRECTORY}/src/xbt/graphxml.c ${CMAKE_HOME_DIRECTORY}/src/simdag/dax_dtd.c DEPENDS ${CMAKE_HOME_DIRECTORY}/src/surf/simgrid.dtd ${CMAKE_HOME_DIRECTORY}/src/xbt/graphxml.dtd ${CMAKE_HOME_DIRECTORY}/src/simdag/dax.dtd #${CMAKE_HOME_DIRECTORY}/src/surf/simgrid_dtd.l: ${CMAKE_HOME_DIRECTORY}/src/surf/simgrid.dtd COMMAND ${FLEXML_EXE} --root-tags platform -b 1000000 -P surfxml --sysid=http://simgrid.gforge.inria.fr/simgrid.dtd -S src/surf/simgrid_dtd.l -L src/surf/simgrid.dtd COMMAND ${SED_EXE} -i ${string14} src/surf/simgrid_dtd.l COMMAND ${CMAKE_COMMAND} -E echo "src/surf/simgrid_dtd.l" #${CMAKE_HOME_DIRECTORY}/src/xbt/graphxml.l: ${CMAKE_HOME_DIRECTORY}/src/xbt/graphxml.dtd COMMAND ${FLEXML_EXE} -b 1000000 -P graphxml --sysid=graphxml.dtd -S src/xbt/graphxml.l -L src/xbt/graphxml.dtd COMMAND ${SED_EXE} -i ${string14} src/xbt/graphxml.l COMMAND ${CMAKE_COMMAND} -E echo "src/xbt/graphxml.l" #${CMAKE_HOME_DIRECTORY}/src/simdag/dax_dtd.l: ${CMAKE_HOME_DIRECTORY}/src/simdag/dax.dtd COMMAND ${FLEXML_EXE} -b 1000000 --root-tags adag -P dax_ --sysid=dax.dtd -S src/simdag/dax_dtd.l -L src/simdag/dax.dtd COMMAND ${SED_EXE} -i ${string5} src/simdag/dax_dtd.l COMMAND ${SED_EXE} -i ${string14} src/simdag/dax_dtd.l COMMAND ${CMAKE_COMMAND} -E echo "src/simdag/dax_dtd.l" #${CMAKE_HOME_DIRECTORY}/include/surf/simgrid_dtd.h: ${CMAKE_HOME_DIRECTORY}/src/surf/simgrid.dtd COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_HOME_DIRECTORY}/include/surf/simgrid.h COMMAND ${FLEXML_EXE} --root-tags platform -P surfxml --sysid=http://simgrid.gforge.inria.fr/simgrid.dtd -H include/surf/simgrid_dtd.h -L src/surf/simgrid.dtd COMMAND ${SED_EXE} -i ${string1} include/surf/simgrid_dtd.h COMMAND ${SED_EXE} -i ${string2} include/surf/simgrid_dtd.h COMMAND ${SED_EXE} -i ${string14} include/surf/simgrid_dtd.h COMMAND ${CMAKE_COMMAND} -E echo "include/surf/simgrid_dtd.h" #${CMAKE_HOME_DIRECTORY}/include/xbt/graphxml.h: ${CMAKE_HOME_DIRECTORY}/src/xbt/graphxml.dtd COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_HOME_DIRECTORY}/include/xbt/graphxml.h COMMAND ${FLEXML_EXE} -P graphxml --sysid=graphxml.dtd -H include/xbt/graphxml.h -L src/xbt/graphxml.dtd COMMAND ${SED_EXE} -i ${string1} include/xbt/graphxml.h COMMAND ${SED_EXE} -i ${string2} include/xbt/graphxml.h COMMAND ${SED_EXE} -i ${string14} include/xbt/graphxml.h COMMAND ${CMAKE_COMMAND} -E echo "include/xbt/graphxml.h" #${CMAKE_HOME_DIRECTORY}/src/simdag/dax_dtd.h: ${CMAKE_HOME_DIRECTORY}/src/simdag/dax.dtd COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_HOME_DIRECTORY}/src/simdag/dax_dtd.h COMMAND ${FLEXML_EXE} --root-tags adag -P dax_ --sysid=dax.dtd -H src/simdag/dax_dtd.h -L src/simdag/dax.dtd COMMAND ${SED_EXE} -i ${string1} src/simdag/dax_dtd.h COMMAND ${SED_EXE} -i ${string2} src/simdag/dax_dtd.h COMMAND ${SED_EXE} -i ${string14} src/simdag/dax_dtd.h COMMAND ${CMAKE_COMMAND} -E echo "src/simdag/dax_dtd.h" #surf/simgrid_dtd.c: surf/simgrid_dtd.l COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_HOME_DIRECTORY}/src/surf/simgrid_dtd.c COMMAND ${SED_EXE} -i ${string8} src/surf/simgrid_dtd.l COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_HOME_DIRECTORY}/src/surf COMMAND ${FLEX_EXE} -o src/surf/simgrid_dtd.c -Psurf_parse_ --noline src/surf/simgrid_dtd.l COMMAND ${SED_EXE} -i ${string9} src/surf/simgrid_dtd.c COMMAND ${SED_EXE} -i ${string15} src/surf/simgrid_dtd.c COMMAND ${CMAKE_COMMAND} -E echo "surf/simgrid_dtd.c" #xbt/graphxml.c: xbt/graphxml.l COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_HOME_DIRECTORY}/src/xbt/graphxml.c COMMAND ${SED_EXE} -i ${string8} src/xbt/graphxml.l COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_HOME_DIRECTORY}/src/xbt COMMAND ${FLEX_EXE} -o src/xbt/graphxml.c -Pxbt_graph_parse_ --noline src/xbt/graphxml.l COMMAND ${SED_EXE} -i ${string9} src/xbt/graphxml.c COMMAND ${CMAKE_COMMAND} -E echo "xbt/graphxml.c" #simdag/dax_dtd.c: simdag/dax_dtd.l COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_HOME_DIRECTORY}/src/simdag/dax_dtd.c COMMAND ${SED_EXE} -i ${string8} src/simdag/dax_dtd.l COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_HOME_DIRECTORY}/src/simdag COMMAND ${FLEX_EXE} -o src/simdag/dax_dtd.c -Pdax_ --noline src/simdag/dax_dtd.l COMMAND ${SED_EXE} -i ${string9} src/simdag/dax_dtd.c COMMAND ${CMAKE_COMMAND} -E echo "simdag/dax_dtd.c" WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY} COMMENT "Generating files in maintainer mode..." ) add_custom_target(maintainer_files DEPENDS ${CMAKE_HOME_DIRECTORY}/include/surf/simgrid_dtd.h ${CMAKE_HOME_DIRECTORY}/include/xbt/graphxml.h ${CMAKE_HOME_DIRECTORY}/src/simdag/dax_dtd.h ${CMAKE_HOME_DIRECTORY}/src/surf/simgrid_dtd.c ${CMAKE_HOME_DIRECTORY}/src/xbt/graphxml.c ${CMAKE_HOME_DIRECTORY}/src/simdag/dax_dtd.c ) else() if(NOT HAVE_FLEXML) message(STATUS "Error : Install flexml before use maintainer mode.") endif() if(NOT HAVE_FLEX) message(STATUS "Error : Install flex before use maintainer mode.") endif() if(NOT SED_EXE) message(STATUS "Error : Install sed before use maintainer mode.") endif() message(FATAL_ERROR STATUS "Error : Need to install all tools for maintainer mode !!!") endif() endif() SimGrid-3.11/buildtools/Cmake/CTestCustom.cmake000644 001750 001750 00000000074 12342443653 020452 0ustar00cici000000 000000 SET(CTEST_CUSTOM_COVERAGE_EXCLUDE @PATTERN_CTEST_IGNORED@ )SimGrid-3.11/buildtools/Cmake/MakeExe.cmake000644 001750 001750 00000023703 12342443653 017560 0ustar00cici000000 000000 ################################################################### ### Load all files declaring binaries (tools, examples and tests) # ################################################################### add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/async) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/bittorrent) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/chord) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/cloud) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/cloud/migration) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/commTime) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/io) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/kademlia) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/master_slave_bypass) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/master_slave_kill) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/masterslave) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/migration) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/mutualExclusion) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/pingPong) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/priority) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/reservationSurfPlugin) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/startKillTime) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/surfCpuModel) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/surfPlugin) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/suspend) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/java/tracing) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/lua) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/actions) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/bittorrent) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/chainsend) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/chord) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/cloud) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/energy/e1) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/energy/e2) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/energy/e3) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/gpu) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/gtnets) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/icomms) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/io) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/kademlia) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/mc) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/migration) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/ns3) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/parallel_task) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/pastry) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/pmm) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/priority) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/properties) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/semaphores) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/sendrecv) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/start_kill_time) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/suspend) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/token_ring) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/msg/tracing) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/scala) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/scala/master_slave_bypass) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/scala/master_slave_kill) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/scala/masterslave) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/simdag) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/simdag/dax) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/simdag/dot) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/simdag/goal) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/simdag/io) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/simdag/metaxml) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/simdag/properties) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/simdag/scheduling) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/smpi) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/smpi/MM) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/smpi/smpi_msg_masterslave) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/smpi/energy) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/smpi/energy/f77) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/smpi/energy/f90) add_subdirectory(${CMAKE_HOME_DIRECTORY}/examples/xbt) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/mc/dwarf) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/mc/dwarf_expression) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/msg) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/msg/get_sender) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/msg/host_on_off) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/msg/pid) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/msg/process) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/msg/process_join) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/msg/storage) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/msg/task_destroy_cancel) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/msg/trace) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/availability) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/basic) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/incomplete) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/network) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/network/mxn) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/network/p2p) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/partask) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/platforms) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/bug-17132) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/simix/check_defaults) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/simix/stack_overflow) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/allgather) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/allgatherv) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/allreduce) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/alltoall) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/alltoallv) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/barrier) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/bcast) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/compute) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/gather) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/hvector) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/indexed) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/pingpong) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/reduce) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/scatter) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/shared) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/struct) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/vector) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/attr) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/comm) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/datatype) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/group) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/topo) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/init) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/pt2pt) #add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f77/attr) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f77/util) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f77/coll) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f77/comm) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f77/datatype) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f77/ext) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f77/init) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f77/pt2pt) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f90/util) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f90/coll) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f90/datatype) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f90/init) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f90/pt2pt) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/surf/) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/surf/lmm_usage) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/surf/maxmin_bench) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/surf/surf_usage) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/surf/trace_usage) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/graphxml_usage) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/heap_bench) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/log_large) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/log_usage) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/mmalloc) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/parallel_log) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/parmap_bench) add_subdirectory(${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/parmap_test) add_subdirectory(${CMAKE_HOME_DIRECTORY}/tools) add_subdirectory(${CMAKE_HOME_DIRECTORY}/tools/graphicator) add_subdirectory(${CMAKE_HOME_DIRECTORY}/tools/tesh) SimGrid-3.11/buildtools/Cmake/AddTests.cmake000644 001750 001750 00000171544 12342443653 017763 0ustar00cici000000 000000 IF(enable_memcheck) include(FindValgrind) ENDIF() IF(enable_smpi AND NOT WIN32) exec_program("chmod a=rwx ${CMAKE_BINARY_DIR}/bin/smpicc" OUTPUT_VARIABLE "OKITOKI") exec_program("chmod a=rwx ${CMAKE_BINARY_DIR}/bin/smpicxx" OUTPUT_VARIABLE "OKITOKI") exec_program("chmod a=rwx ${CMAKE_BINARY_DIR}/bin/smpif2c" OUTPUT_VARIABLE "OKITOKI") exec_program("chmod a=rwx ${CMAKE_BINARY_DIR}/bin/smpiff" OUTPUT_VARIABLE "OKITOKI") exec_program("chmod a=rwx ${CMAKE_BINARY_DIR}/bin/smpif90" OUTPUT_VARIABLE "OKITOKI") exec_program("chmod a=rwx ${CMAKE_BINARY_DIR}/bin/smpirun" OUTPUT_VARIABLE "OKITOKI") ENDIF() ### For code coverage ### Set some variables SET(UPDATE_TYPE "svn") SET(DROP_METHOD "http") SET(DROP_SITE "cdash.inria.fr/CDash") SET(DROP_LOCATION "/submit.php?project=${PROJECT_NAME}") SET(DROP_SITE_CDASH TRUE) SET(TRIGGER_SITE "http://cdash.inria.fr/CDash/cgi-bin/Submit-Random-TestingResults.cgi") #If you use the --read-var-info option Memcheck will run more slowly but may give a more detailed description of any illegal address. IF(WIN32) SET(TESH_COMMAND perl.exe ${CMAKE_BINARY_DIR}/bin/tesh) SET(TESH_OPTION $TESH_OPTION --timeout 50) ELSE() SET(TESH_COMMAND ${CMAKE_BINARY_DIR}/bin/tesh) ENDIF() #some tests may take forever on non futexes systems, using busy_wait with n cores < n workers # default to posix for these tests if futexes are not supported IF(NOT HAVE_FUTEX_H) SET(CONTEXTS_SYNCHRO --cfg contexts/synchro:posix) ENDIF() MACRO(ADD_TESH NAME) SET(ARGR ${ARGV}) LIST(REMOVE_AT ARGR 0) IF(WIN32) STRING(REPLACE "§" "\;" ARGR "${ARGR}") ENDIF() ADD_TEST(${NAME} ${TESH_COMMAND} ${TESH_OPTION} ${ARGR}) ENDMACRO() MACRO(ADD_TESH_FACTORIES NAME FACTORIES) SET(ARGR ${ARGV}) LIST(REMOVE_AT ARGR 0) # remove name FOREACH(I ${FACTORIES}) # remove all factories LIST(REMOVE_AT ARGR 0) ENDFOREACH() FOREACH(FACTORY ${FACTORIES}) if ((${FACTORY} STREQUAL "thread") OR (${FACTORY} STREQUAL "raw" AND HAVE_RAWCTX) OR (${FACTORY} STREQUAL "ucontext" AND CONTEXT_UCONTEXT)) ADD_TESH("${NAME}-${FACTORY}" "--cfg" "contexts/factory:${FACTORY}" ${ARGR}) ENDIF() ENDFOREACH() ENDMACRO() INCLUDE(CTest) ENABLE_TESTING() IF(NOT enable_memcheck) ## CORE ## ### TESH ### ADD_TESH(tesh-self-basic --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/basic.tesh) ADD_TESH(tesh-self-cd --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/cd.tesh) ADD_TESH(tesh-self-IO-broken-pipe --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/IO-broken-pipe.tesh) ADD_TESH(tesh-self-IO-orders --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/IO-orders.tesh) ADD_TESH(tesh-self-IO-bigsize --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/IO-bigsize.tesh) ADD_TESH(tesh-self-set-return --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/set-return.tesh) ADD_TESH(tesh-self-set-timeout --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/set-timeout.tesh) ADD_TESH(tesh-self-set-output-ignore --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/set-output-ignore.tesh) ADD_TESH(tesh-self-set-output-sort --setenv bindir=${CMAKE_BINARY_DIR}/bin --cd "${CMAKE_HOME_DIRECTORY}/tools/tesh" set-output-sort.tesh) ADD_TESH(tesh-self-catch-return --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/catch-return.tesh) ADD_TESH(tesh-self-catch-timeout --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/catch-timeout.tesh) ADD_TESH(tesh-self-catch-wrong-output --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/catch-wrong-output.tesh) ADD_TESH(tesh-self-bg-basic --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/bg-basic.tesh) ADD_TESH(tesh-self-background --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/background.tesh) IF(NOT WIN32) ADD_TESH(tesh-self-set-signal --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/set-signal.tesh) ADD_TESH(tesh-self-bg-set-signal --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/bg-set-signal.tesh) ADD_TESH(tesh-self-catch-signal --cd "${CMAKE_BINARY_DIR}/bin" ${CMAKE_HOME_DIRECTORY}/tools/tesh/catch-signal.tesh) ENDIF() ### GENERIC ### # BEGIN TESH TESTS # test for code coverage ADD_TEST(test-help ${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms/basic_parsing_test --help) ADD_TEST(test-help-models ${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms/basic_parsing_test --help-models) IF(HAVE_TRACING) ADD_TEST(test-tracing-help ${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms/basic_parsing_test --help-tracing) ADD_TESH(graphicator --setenv srcdir=${CMAKE_HOME_DIRECTORY} --setenv bindir=${CMAKE_BINARY_DIR}/bin --cd ${CMAKE_HOME_DIRECTORY}/tools/graphicator graphicator.tesh) ENDIF() # END TESH TESTS ### MC ### IF(HAVE_MC) ADD_TESH(tesh-mc-dwarf --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/mc/dwarf --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/mc/dwarf dwarf.tesh) ADD_TESH(tesh-mc-dwarf-expression --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/mc/dwarf_expression --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/mc/dwarf_expression dwarf_expression.tesh) ADD_TESH_FACTORIES(mc-bugged1 "ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/mc --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/mc bugged1.tesh) ADD_TESH_FACTORIES(mc-bugged2 "ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/mc --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/mc bugged2.tesh) IF(CONTEXT_UCONTEXT AND PROCESSOR_x86_64) # liveness model-checking works only on 64bits (for now ...) ADD_TESH(mc-bugged1-liveness-ucontext --cfg contexts/factory:ucontext --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/mc --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/mc bugged1_liveness.tesh) ADD_TESH(mc-bugged1-liveness-visited-ucontext --cfg contexts/factory:ucontext --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/mc --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/mc bugged1_liveness_visited.tesh) ENDIF() ENDIF() ### SIMIX ### # BEGIN TESH TESTS IF(HAVE_RAWCTX) ADD_TESH(tesh-simix-factory-default --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simix/check_defaults --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simix/check_defaults factory_raw.tesh) ELSEIF(CONTEXT_UCONTEXT) ADD_TESH(tesh-simix-factory-default --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simix/check_defaults --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simix/check_defaults factory_ucontext.tesh) ELSE() ADD_TESH(tesh-simix-factory-default --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simix/check_defaults --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simix/check_defaults factory_thread.tesh) ENDIF() ADD_TESH(tesh-simix-factory-thread --cfg contexts/factory:thread --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simix/check_defaults --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simix/check_defaults factory_thread.tesh) IF(HAVE_RAWCTX) ADD_TESH(tesh-simix-factory-raw --cfg contexts/factory:raw --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simix/check_defaults --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simix/check_defaults factory_raw.tesh) ENDIF() IF(CONTEXT_UCONTEXT) ADD_TESH(tesh-simix-factory-ucontext --cfg contexts/factory:ucontext --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simix/check_defaults --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simix/check_defaults factory_ucontext.tesh) ENDIF() # END TESH TESTS ADD_TESH_FACTORIES(stack-overflow "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simix/stack_overflow --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simix/stack_overflow stack_overflow.tesh) ### ### Declare that we know that some tests are broken ### IF(release) IF(WIN32 OR CMAKE_SYSTEM_NAME MATCHES "Darwin") # These tests are known to fail on Windows and Mac OS X # (the expected error message is not shown). SET_TESTS_PROPERTIES(stack-overflow-thread PROPERTIES WILL_FAIL true) IF(CONTEXT_UCONTEXT) SET_TESTS_PROPERTIES(stack-overflow-ucontext PROPERTIES WILL_FAIL true) ENDIF() IF(HAVE_RAWCTX) SET_TESTS_PROPERTIES(stack-overflow-raw PROPERTIES WILL_FAIL true) ENDIF() ENDIF() ENDIF() ### SURF ### # BEGIN TESH TESTS ADD_TESH(tesh-surf-lmm --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/surf/lmm_usage --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/surf/lmm_usage lmm_usage.tesh) ADD_TESH(tesh-surf-maxmin --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/surf/maxmin_bench --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/surf/maxmin_bench maxmin_bench.tesh) ADD_TESH(tesh-surf-usage --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/surf/surf_usage --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/surf/ surf_usage/surf_usage.tesh) ADD_TESH(tesh-surf-trace --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/surf/trace_usage --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/surf/ trace_usage/trace_usage.tesh) # END TESH TESTS ### XBT ### # BEGIN TESH TESTS ADD_TESH(tesh-xbt-log-large --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/xbt/log_large --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/log_large log_large_test.tesh) ADD_TESH(tesh-xbt-log-parallel --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/xbt/parallel_log --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/parallel_log parallel_log_crashtest.tesh) IF(HAVE_MMALLOC) IF(${ARCH_32_BITS}) ADD_TESH(tesh-xbt-mmalloc-32 --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/xbt/mmalloc --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/mmalloc mmalloc_32.tesh) ELSE() ADD_TESH(tesh-xbt-mmalloc-64 --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/xbt/mmalloc --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/mmalloc mmalloc_64.tesh) ENDIF() ENDIF() ADD_TESH(tesh-xbt-parmap --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/xbt/parmap_test --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/parmap_test parmap_test.tesh) ADD_TESH(tesh-xbt-log --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/xbt/log_usage --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/log_usage log_usage.tesh) ADD_TESH(tesh-xbt-graphxml --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/xbt/graphxml_usage --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/graphxml_usage graphxml_usage.tesh) ADD_TESH(tesh-xbt-heap --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/xbt/heap_bench --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/heap_bench heap_bench.tesh) #ADD_TESH(test-xbt-parmap --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/xbt/parmap_bench --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/xbt/parmap_bench parmap_bench.tesh) # END TESH TESTS ## INTERFACES ## ### MSG ### # BEGIN TESH TESTS ADD_TESH_FACTORIES(tesh-msg-get-sender "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/msg/get_sender --cd ${CMAKE_BINARY_DIR}/teshsuite/msg/get_sender ${CMAKE_HOME_DIRECTORY}/teshsuite/msg/get_sender/get_sender.tesh) ADD_TESH_FACTORIES(tesh-msg-host-on-off "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/msg/host_on_off --cd ${CMAKE_BINARY_DIR}/teshsuite/msg/host_on_off ${CMAKE_HOME_DIRECTORY}/teshsuite/msg/host_on_off/host_on_off.tesh) ADD_TESH_FACTORIES(tesh-msg-pid "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/msg/pid --cd ${CMAKE_BINARY_DIR}/teshsuite/msg/pid ${CMAKE_HOME_DIRECTORY}/teshsuite/msg/pid/pid.tesh) ADD_TESH_FACTORIES(tesh-msg-process "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/msg/process --cd ${CMAKE_BINARY_DIR}/teshsuite/msg/process ${CMAKE_HOME_DIRECTORY}/teshsuite/msg/process/process.tesh) ADD_TESH_FACTORIES(tesh-msg-process-join "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/msg/process_join --cd ${CMAKE_BINARY_DIR}/teshsuite/msg/process_join ${CMAKE_HOME_DIRECTORY}/teshsuite/msg/process_join/process_join.tesh) ADD_TESH_FACTORIES(tesh-msg-storage-basic "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/msg/storage --cd ${CMAKE_BINARY_DIR}/teshsuite/msg/storage ${CMAKE_HOME_DIRECTORY}/teshsuite/msg/storage/storage_basic.tesh) ADD_TESH_FACTORIES(tesh-msg-task-destroy-cancel "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/msg/task_destroy_cancel --cd ${CMAKE_BINARY_DIR}/teshsuite/msg/task_destroy_cancel ${CMAKE_HOME_DIRECTORY}/teshsuite/msg/task_destroy_cancel/task_destroy_cancel.tesh) ADD_TESH_FACTORIES(tesh-msg-trace "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/msg/trace --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/msg/trace ${CMAKE_HOME_DIRECTORY}/teshsuite/msg/trace/trace.tesh) ADD_TESH(msg-file --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/ --setenv srcdir=${CMAKE_HOME_DIRECTORY}/ --cd ${CMAKE_HOME_DIRECTORY}/examples/ ${CMAKE_HOME_DIRECTORY}/examples/msg/io/io.tesh) ADD_TESH(msg-storage --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/ --setenv srcdir=${CMAKE_HOME_DIRECTORY}/ --cd ${CMAKE_HOME_DIRECTORY}/examples/ ${CMAKE_HOME_DIRECTORY}/examples/msg/io/storage.tesh) ADD_TESH(msg-remote-io --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/ --setenv srcdir=${CMAKE_HOME_DIRECTORY}/ --cd ${CMAKE_HOME_DIRECTORY}/examples/ ${CMAKE_HOME_DIRECTORY}/examples/msg/io/remote.tesh) ADD_TESH(msg-start-kill-time --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/ --setenv srcdir=${CMAKE_HOME_DIRECTORY}/ --cd ${CMAKE_HOME_DIRECTORY}/examples/ ${CMAKE_HOME_DIRECTORY}/examples/msg/start_kill_time/start_kill_time.tesh) ADD_TESH(msg-chainsend --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/chainsend --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg/chainsend --cd ${CMAKE_HOME_DIRECTORY}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/chainsend/chainsend.tesh) ADD_TESH_FACTORIES(msg-sendrecv-CLM03 "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/sendrecv/sendrecv_CLM03.tesh) ADD_TESH_FACTORIES(msg-sendrecv-Vegas "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/sendrecv/sendrecv_Vegas.tesh) ADD_TESH_FACTORIES(msg-sendrecv-Reno "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/sendrecv/sendrecv_Reno.tesh) ADD_TESH_FACTORIES(msg-suspend "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/suspend/suspend.tesh) ADD_TESH_FACTORIES(msg-pmm "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/pmm/pmm.tesh) ADD_TESH_FACTORIES(msg-masterslave-bypass "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_bypass.tesh) ADD_TESH_FACTORIES(msg-masterslave-kill "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_kill.tesh) ADD_TESH_FACTORIES(msg-masterslave-multicore "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_multicore.tesh) ADD_TESH_FACTORIES(msg-masterslave-no-crosstraffic-mailbox "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_mailbox.tesh) ADD_TESH_FACTORIES(msg-masterslave-no-crosstraffic "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave.tesh) ADD_TESH_FACTORIES(msg-masterslave-no-crosstraffic-forwarder "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_forwarder.tesh) ADD_TESH_FACTORIES(msg-masterslave-no-crosstraffic-failure "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_failure.tesh) ADD_TESH_FACTORIES(msg-masterslave "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_crosstraffic.tesh) ADD_TESH_FACTORIES(msg-masterslave-forwarder "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_forwarder_crosstraffic.tesh) ADD_TESH_FACTORIES(msg-masterslave-failure "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_failure_crosstraffic.tesh) ADD_TESH_FACTORIES(msg-masterslave-mailbox "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_mailbox_crosstraffic.tesh) ADD_TESH_FACTORIES(msg-masterslave-cpu-ti "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/masterslave --cd ${CMAKE_HOME_DIRECTORY}/examples/msg masterslave/masterslave_cpu_ti_crosstraffic.tesh) ADD_TESH_FACTORIES(msg-masterslave-vivaldi "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/masterslave/masterslave_vivaldi.tesh) ADD_TESH_FACTORIES(msg-cloud-two-tasks-vm "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/cloud/ --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/ --cd ${CMAKE_BINARY_DIR}/examples/msg/cloud/ ${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/two_tasks_vm.tesh) ADD_TESH_FACTORIES(msg-cloud-simple-vm "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/cloud/ --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/ --cd ${CMAKE_BINARY_DIR}/examples/msg/cloud/ ${CMAKE_HOME_DIRECTORY}/examples/msg/cloud/simple_vm.tesh) ADD_TESH_FACTORIES(msg-energy-pstates "thread" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/energy/e1/pstate.tesh) ADD_TESH_FACTORIES(msg-energy-consumption "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/energy/e2/energy_consumption.tesh) ADD_TESH_FACTORIES(msg-energy-concurrent-tasks "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/energy/e3/concurrent_tasks.tesh) ADD_TESH_FACTORIES(msg-token-ring "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY} --cd ${CMAKE_BINARY_DIR}/examples/msg/token_ring ${CMAKE_HOME_DIRECTORY}/examples/msg/token_ring/token_ring.tesh) ADD_TESH_FACTORIES(msg-migration "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/migration/migration.tesh) ADD_TESH_FACTORIES(msg-ptask "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/parallel_task/parallel_task.tesh) ADD_TESH_FACTORIES(msg-priority "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/priority/priority.tesh) ADD_TESH_FACTORIES(msg-properties "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/properties/msg_prop.tesh) ADD_TESH_FACTORIES(msg-icomms "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg/icomms --cd ${CMAKE_BINARY_DIR}/examples/msg/icomms ${CMAKE_HOME_DIRECTORY}/examples/msg/icomms/peer.tesh) ADD_TESH_FACTORIES(msg-actions "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/actions --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/actions actions.tesh) ADD_TESH_FACTORIES(msg-chord-no-crosstraffic "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/chord --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/chord chord.tesh) ADD_TESH_FACTORIES(msg-chord-no-crosstraffic-parallel "thread;ucontext;raw" --cfg contexts/nthreads:4 ${CONTEXTS_SYNCHRO} --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/chord --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/chord chord.tesh) ADD_TESH_FACTORIES(msg-chord "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/chord --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/chord chord_crosstraffic.tesh) ADD_TESH_FACTORIES(msg-chord-parallel "thread;ucontext;raw" --cfg contexts/nthreads:4 ${CONTEXTS_SYNCHRO} --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/chord --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/chord chord_crosstraffic.tesh) ADD_TESH_FACTORIES(msg-bittorrent "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/bittorrent --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/bittorrent bittorrent.tesh) ADD_TESH_FACTORIES(msg-bittorrent-parallel "thread;ucontext;raw" --cfg contexts/nthreads:4 ${CONTEXTS_SYNCHRO} --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/bittorrent --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/bittorrent bittorrent.tesh) ADD_TESH_FACTORIES(msg-kademlia "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/kademlia --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/kademlia kademlia.tesh) ADD_TESH_FACTORIES(msg-kademlia-parallel "thread;ucontext;raw" --cfg contexts/nthreads:4 --cfg contexts/factory:thread ${CONTEXTS_SYNCHRO} --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg/kademlia --cd ${CMAKE_HOME_DIRECTORY}/examples/msg/kademlia kademlia.tesh) ADD_TESH_FACTORIES(msg-gtnets-crosstraffic "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/gtnets/gtnets-crosstraffic.tesh) IF(HAVE_GTNETS) ADD_TESH_FACTORIES(msg-gtnets-waxman "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/gtnets/gtnets-waxman.tesh) ADD_TESH_FACTORIES(msg-gtnets-dogbone "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/gtnets/gtnets-dogbone-gtnets.tesh) ADD_TESH_FACTORIES(msg-gtnets-onelink "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/gtnets/gtnets-onelink-gtnets.tesh) ADD_TESH_FACTORIES(msg-gtnets-dogbone-lv08 "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/gtnets/gtnets-dogbone-lv08.tesh) ADD_TESH_FACTORIES(msg-gtnets-onelink-lv08 "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/gtnets/gtnets-onelink-lv08.tesh) IF(HAVE_TRACING) ADD_TESH(msg-tracing-gtnets-waxman --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/gtnets/tracing-gtnets-waxman.tesh) ADD_TESH(msg-tracing-gtnets-dogbone --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/gtnets/tracing-gtnets-dogbone-gtnets.tesh) ADD_TESH(msg-tracing-gtnets-onelink --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/gtnets/tracing-gtnets-onelink-gtnets.tesh) ADD_TESH(msg-tracing-gtnets-dogbone-lv08 --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/gtnets/tracing-gtnets-dogbone-lv08.tesh) ADD_TESH(msg-tracing-gtnets-onelink-lv08 --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/msg --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/gtnets/tracing-gtnets-onelink-lv08.tesh) ENDIF() ENDIF() IF(HAVE_NS3) ADD_TESH_FACTORIES(msg-ns3 "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY} --cd ${CMAKE_BINARY_DIR}/examples/msg ${CMAKE_HOME_DIRECTORY}/examples/msg/ns3/ns3.tesh) ENDIF() IF(HAVE_TRACING) ADD_TESH(tracing-ms --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg --cd ${CMAKE_HOME_DIRECTORY}/examples/msg tracing/ms.tesh) ADD_TESH(tracing-trace-platform --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg --cd ${CMAKE_HOME_DIRECTORY}/examples/msg tracing/trace_platform.tesh) ADD_TESH(tracing-user-variables --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg --cd ${CMAKE_HOME_DIRECTORY}/examples/msg tracing/user_variables.tesh) ADD_TESH(tracing-link-user-variables --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg --cd ${CMAKE_HOME_DIRECTORY}/examples/msg tracing/link_user_variables.tesh) ADD_TESH(tracing-link-srcdst-user-variables --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg --cd ${CMAKE_HOME_DIRECTORY}/examples/msg tracing/link_srcdst_user_variables.tesh) ADD_TESH(tracing-categories --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg --cd ${CMAKE_HOME_DIRECTORY}/examples/msg tracing/categories.tesh) ADD_TESH(tracing-process-migration --setenv bindir=${CMAKE_BINARY_DIR}/examples/msg --cd ${CMAKE_HOME_DIRECTORY}/examples/msg tracing/procmig.tesh) ENDIF() ADD_TEST(msg-icomms-waitany ${CMAKE_BINARY_DIR}/examples/msg/icomms/peer3 ${CMAKE_HOME_DIRECTORY}/examples/msg/icomms/small_platform.xml ${CMAKE_HOME_DIRECTORY}/examples/msg/icomms/deployment_peer05.xml) # END TESH TESTS ### SIMDAG ### # BEGIN TESH TESTS # these tests need the assertion mechanism # exclude them from memcheck, as they normally die, leaving lots of unfree'd objects IF(enable_debug AND NOT enable_memcheck) ADD_TESH(tesh-parser-bogus-symmetric --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/platforms bogus_two_hosts_asymetric.tesh) ADD_TESH(tesh-parser-bogus-missing-gw --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/platforms bogus_missing_gateway.tesh) ADD_TESH(tesh-parser-bogus-disk-attachment --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/platforms bogus_disk_attachment.tesh) ENDIF() ADD_TESH(tesh-simdag-bypass --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms --setenv srcdir=${CMAKE_HOME_DIRECTORY} --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/platforms basic_parsing_test_bypass.tesh) ADD_TESH(tesh-simdag-flatifier --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms --setenv srcdir=${CMAKE_HOME_DIRECTORY} --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/platforms flatifier.tesh) ADD_TESH(tesh-simdag-link --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms --setenv srcdir=${CMAKE_HOME_DIRECTORY} --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/platforms basic_link_test.tesh) ADD_TESH(tesh-simdag-reinit-costs --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite --cd ${CMAKE_BINARY_DIR}/teshsuite ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/network/test_reinit_costs.tesh) ADD_TESH(tesh-simdag-parser --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/platforms basic_parsing_test.tesh) ADD_TESH(tesh-simdag-parser-sym-full --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/platforms basic_parsing_test_sym_full.tesh) ADD_TESH(tesh-simdag-full-links --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/platforms get_full_link.tesh) ADD_TESH(tesh-simdag-basic0 --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/basic --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/basic basic0.tesh) ADD_TESH(tesh-simdag-basic1 --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/basic --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/basic basic1.tesh) ADD_TESH(tesh-simdag-basic2 --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/basic --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/basic basic2.tesh) ADD_TESH(tesh-simdag-basic3 --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/basic --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/basic basic3.tesh) ADD_TESH(tesh-simdag-basic4 --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/basic --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/basic basic4.tesh) ADD_TESH(tesh-simdag-basic5 --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/basic --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/basic basic5.tesh) ADD_TESH(tesh-simdag-basic6 --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/basic --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/basic basic6.tesh) ADD_TESH(tesh-simdag-incomplete --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/simdag/incomplete --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/incomplete incomplete.tesh) ADD_TESH(tesh-simdag-p2p-1 --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite --cd ${CMAKE_BINARY_DIR}/teshsuite ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/network/p2p/test_latency1.tesh) ADD_TESH(tesh-simdag-p2p-2 --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite --cd ${CMAKE_BINARY_DIR}/teshsuite ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/network/p2p/test_latency2.tesh) ADD_TESH(tesh-simdag-p2p-3 --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite --cd ${CMAKE_BINARY_DIR}/teshsuite ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/network/p2p/test_latency3.tesh) ADD_TESH(tesh-simdag-p2p-4 --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite --cd ${CMAKE_BINARY_DIR}/teshsuite ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/network/p2p/test_latency_bound.tesh) ADD_TESH(tesh-simdag-mxn-1 --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite --cd ${CMAKE_BINARY_DIR}/teshsuite ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/network/mxn/test_intra_all2all.tesh) ADD_TESH(tesh-simdag-mxn-2 --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite --cd ${CMAKE_BINARY_DIR}/teshsuite ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/network/mxn/test_intra_independent_comm.tesh) ADD_TESH(tesh-simdag-mxn-3 --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite --cd ${CMAKE_BINARY_DIR}/teshsuite ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/network/mxn/test_intra_scatter.tesh) ADD_TESH(tesh-simdag-par-1 --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite --cd ${CMAKE_BINARY_DIR}/teshsuite ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/partask/test_comp_only_seq.tesh) ADD_TESH(tesh-simdag-par-2 --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite --cd ${CMAKE_BINARY_DIR}/teshsuite ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/partask/test_comp_only_par.tesh) ADD_TESH(tesh-simdag-availability --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite --cd ${CMAKE_BINARY_DIR}/teshsuite ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/availability/availability_test.tesh) ADD_TEST(tesh-simdag-full-links01 ${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms/basic_parsing_test ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/platforms/two_clusters.xml FULL_LINK) ADD_TEST(tesh-simdag-full-links02 ${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms/basic_parsing_test ${CMAKE_HOME_DIRECTORY}/teshsuite/simdag/platforms/two_clusters_one_name.xml FULL_LINK) ADD_TEST(tesh-simdag-one-link-g5k ${CMAKE_BINARY_DIR}/teshsuite/simdag/platforms/basic_parsing_test ${CMAKE_HOME_DIRECTORY}/examples/platforms/g5k.xml ONE_LINK) # END TESH TESTS # BEGIN TESH TESTS IF(HAVE_GRAPHVIZ) IF(HAVE_TRACING) ADD_TESH(simdag-dotload --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/simdag/dot --cd ${CMAKE_BINARY_DIR}/examples/simdag/dot ${CMAKE_HOME_DIRECTORY}/examples/simdag/dot/test_simdag_dotload.tesh) ELSE() ADD_TESH(simdag-dotload --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/simdag/dot --cd ${CMAKE_BINARY_DIR}/examples/simdag/dot ${CMAKE_HOME_DIRECTORY}/examples/simdag/dot/test_simdag_dotload_notrace.tesh) ENDIF() ENDIF() ADD_TESH(simdag-simdag --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/simdag --cd ${CMAKE_BINARY_DIR}/examples/simdag ${CMAKE_HOME_DIRECTORY}/examples/simdag/test_simdag.tesh) ADD_TESH(simdag-simdag2 --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/simdag --cd ${CMAKE_BINARY_DIR}/examples/simdag ${CMAKE_HOME_DIRECTORY}/examples/simdag/test_simdag2.tesh) ADD_TESH(simdag-seq-access --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/simdag --cd ${CMAKE_BINARY_DIR}/examples/simdag ${CMAKE_HOME_DIRECTORY}/examples/simdag/test_simdag_seq_access.tesh) ADD_TESH(simdag-typed-tasks --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/simdag --cd ${CMAKE_BINARY_DIR}/examples/simdag ${CMAKE_HOME_DIRECTORY}/examples/simdag/test_simdag_typed_tasks.tesh) IF(HAVE_TRACING) ADD_TESH(simdag-fail --setenv bindir=${CMAKE_BINARY_DIR}/examples/simdag --cd ${CMAKE_HOME_DIRECTORY}/examples/simdag test_simdag_fail.tesh) ELSE() ADD_TESH(simdag-fail --setenv bindir=${CMAKE_BINARY_DIR}/examples/simdag --cd ${CMAKE_HOME_DIRECTORY}/examples/simdag test_simdag_fail_notrace.tesh) ENDIF() ADD_TESH(simdag-avail --setenv bindir=${CMAKE_BINARY_DIR}/examples/simdag --cd ${CMAKE_HOME_DIRECTORY}/examples/simdag test_simdag_avail.tesh) ADD_TESH(simdag-comm-throttling --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/simdag --cd ${CMAKE_BINARY_DIR}/examples/simdag ${CMAKE_HOME_DIRECTORY}/examples/simdag/test_simdag_comm_throttling.tesh) IF(HAVE_TRACING) ADD_TESH(simdag-dax --setenv bindir=${CMAKE_BINARY_DIR}/examples/simdag/dax --cd ${CMAKE_HOME_DIRECTORY}/examples/simdag/dax smalldax.tesh) ELSE() ADD_TESH(simdag-dax --setenv bindir=${CMAKE_BINARY_DIR}/examples/simdag/dax --cd ${CMAKE_HOME_DIRECTORY}/examples/simdag/dax smalldax_notrace.tesh) ENDIF() ADD_TESH(simdag-dax-cycle --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/simdag/dax --cd ${CMAKE_BINARY_DIR}/examples/simdag/dax ${CMAKE_HOME_DIRECTORY}/examples/simdag/dax/simple_dax_with_cycle.tesh) ADD_TESH(simdag-prop --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/simdag --cd ${CMAKE_BINARY_DIR}/examples/simdag ${CMAKE_HOME_DIRECTORY}/examples/simdag/properties/test_prop.tesh) ADD_TESH(simdag-minmin-scheduling --setenv bindir=${CMAKE_BINARY_DIR}/examples/simdag/scheduling --cd ${CMAKE_HOME_DIRECTORY}/examples/simdag/scheduling test_minmin.tesh) ADD_TESH(simdag-io --setenv bindir=${CMAKE_BINARY_DIR}/examples/simdag/ --setenv srcdir=${CMAKE_HOME_DIRECTORY}/ --cd ${CMAKE_HOME_DIRECTORY}/examples/ ${CMAKE_HOME_DIRECTORY}/examples/simdag/io/io.tesh) IF(HAVE_TRACING) ADD_TESH(tracing-simdag --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/simdag --cd ${CMAKE_BINARY_DIR}/examples/simdag ${CMAKE_HOME_DIRECTORY}/examples/simdag/test_simdag_tracing.tesh) ENDIF() # END TESH TESTS ### SMPI ### IF(enable_smpi) # BEGIN TESH TESTS # smpi examples ADD_TESH_FACTORIES(tesh-smpi-bcast "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/bcast --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/bcast bcast.tesh) ADD_TESH_FACTORIES(tesh-smpi-reduce "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/reduce --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/reduce reduce.tesh) ADD_TESH_FACTORIES(tesh-smpi-vector "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/vector --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/vector vector.tesh) ADD_TESH_FACTORIES(tesh-smpi-hvector "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/hvector --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/hvector hvector.tesh) ADD_TESH_FACTORIES(tesh-smpi-indexed "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/indexed --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/indexed indexed.tesh) ADD_TESH_FACTORIES(tesh-smpi-struct "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/struct --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/struct struct.tesh) ADD_TESH_FACTORIES(tesh-smpi-pt2pt "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/pingpong --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/pingpong pt2pt.tesh) ADD_TESH_FACTORIES(tesh-smpi-compute "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/compute --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/compute compute.tesh) IF(NOT WIN32) ADD_TESH_FACTORIES(tesh-smpi-shared "thread;ucontext;raw" --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/shared --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/shared shared.tesh) ENDIF() # https://gforge.inria.fr/tracker/index.php?func=detail&aid=17132&group_id=12&atid=165 ADD_TESH_FACTORIES(tesh-smpi-bug-17132 "thread" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/bug-17132 --cd ${CMAKE_BINARY_DIR}/teshsuite/bug-17132 ${CMAKE_HOME_DIRECTORY}/teshsuite/bug-17132/bug-17132.tesh) ADD_TESH_FACTORIES(tesh-smpi-bug-17132-surf-debug "thread" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/bug-17132 --cd ${CMAKE_BINARY_DIR}/teshsuite/bug-17132 ${CMAKE_HOME_DIRECTORY}/teshsuite/bug-17132/bug-17132-surf-debug.tesh) IF(HAVE_TRACING) ADD_TESH(tesh-smpi-replay-ti-tracing --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/pingpong --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/pingpong TI_output.tesh) ENDIF() FOREACH (GATHER_COLL default ompi mpich ompi_basic_linear ompi_linear_sync ompi_binomial) ADD_TESH(tesh-smpi-gather-coll-${GATHER_COLL} --cfg smpi/gather:${GATHER_COLL} --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/gather --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/gather gather_coll.tesh) ENDFOREACH() FOREACH (ALLGATHER_COLL default 2dmesh 3dmesh bruck GB loosely_lr NTSLR NTSLR_NB pair rdb rhv ring SMP_NTS smp_simple spreading_simple ompi mpich ompi_neighborexchange) ADD_TESH(tesh-smpi-allgather-coll-${ALLGATHER_COLL} --cfg smpi/allgather:${ALLGATHER_COLL} --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/allgather --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/allgather allgather_coll.tesh) ENDFOREACH() FOREACH (ALLGATHERV_COLL default GB pair ring ompi mpich ompi_neighborexchange ompi_bruck mpich_rdb mpich_ring) ADD_TESH(tesh-smpi-allgatherv-coll-${ALLGATHERV_COLL} --cfg smpi/allgatherv:${ALLGATHERV_COLL} --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/allgatherv --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/allgatherv allgatherv_coll.tesh) ENDFOREACH() FOREACH (ALLREDUCE_COLL default lr rab1 rab2 rab_rdb rdb smp_binomial smp_binomial_pipeline smp_rdb smp_rsag smp_rsag_lr smp_rsag_rab redbcast ompi mpich ompi_ring_segmented) ADD_TESH(tesh-smpi-allreduce-coll-${ALLREDUCE_COLL} --cfg smpi/allreduce:${ALLREDUCE_COLL} --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/allreduce --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/allreduce allreduce_coll.tesh) ENDFOREACH() FOREACH (ALLREDUCE_COLL_LARGE ompi_ring_segmented) ADD_TESH(tesh-smpi-allreduce-coll-large-${ALLREDUCE_COLL_LARGE} --cfg smpi/allreduce:${ALLREDUCE_COLL_LARGE} --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/allreduce --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/allreduce allreduce_coll_large.tesh) ENDFOREACH() FOREACH (ALLTOALL_COLL 2dmesh 3dmesh pair pair_one_barrier pair_light_barrier pair_mpi_barrier rdb ring ring_light_barrier ring_mpi_barrier ring_one_barrier bruck basic_linear ompi mpich) ADD_TESH(tesh-smpi-alltoall-coll-${ALLTOALL_COLL} --cfg smpi/alltoall:${ALLTOALL_COLL} --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/alltoall --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/alltoall alltoall_coll.tesh) ENDFOREACH() FOREACH (ALLTOALLV_COLL default pair pair_light_barrier pair_mpi_barrier pair_one_barrier ring ring_light_barrier ring_mpi_barrier ring_one_barrier bruck ompi mpich ompi_basic_linear) ADD_TESH(tesh-smpi-alltoallv-coll-${ALLTOALLV_COLL} --cfg smpi/alltoallv:${ALLTOALLV_COLL} --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/alltoallv --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/alltoallv alltoallv_coll.tesh) ENDFOREACH() FOREACH (BCAST_COLL default arrival_pattern_aware arrival_pattern_aware_wait arrival_scatter binomial_tree flattree flattree_pipeline NTSB NTSL NTSL_Isend scatter_LR_allgather scatter_rdb_allgather SMP_binary SMP_binomial SMP_linear ompi mpich ompi_split_bintree ompi_pipeline) ADD_TESH(tesh-smpi-bcast-coll-${BCAST_COLL} --cfg smpi/bcast:${BCAST_COLL} --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/bcast --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/bcast bcast_coll.tesh) ENDFOREACH() FOREACH (REDUCE_COLL default arrival_pattern_aware binomial flat_tree NTSL scatter_gather ompi mpich ompi_chain ompi_binary ompi_basic_linear ompi_binomial ompi_in_order_binary) ADD_TESH(tesh-smpi-reduce-coll-${REDUCE_COLL} --cfg smpi/reduce:${REDUCE_COLL} --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/reduce --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/reduce reduce_coll.tesh) ENDFOREACH() FOREACH (REDUCE_SCATTER_COLL default ompi mpich ompi_basic_recursivehalving ompi_ring mpich_noncomm mpich_pair mpich_rdb) ADD_TESH(tesh-smpi-reduce-scatter-coll-${REDUCE_SCATTER_COLL} --cfg smpi/reduce_scatter:${REDUCE_SCATTER_COLL} --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/reduce --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/reduce reduce_scatter_coll.tesh) ENDFOREACH() FOREACH (SCATTER_COLL default ompi mpich ompi_basic_linear ompi_binomial) ADD_TESH(tesh-smpi-scatter-coll-${SCATTER_COLL} --cfg smpi/scatter:${SCATTER_COLL} --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/scatter --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/scatter scatter_coll.tesh) ENDFOREACH() FOREACH (BARRIER_COLL default ompi mpich ompi_basic_linear ompi_tree ompi_bruck ompi_recursivedoubling ompi_doublering) ADD_TESH(tesh-smpi-barrier-coll-${BARRIER_COLL} --cfg smpi/barrier:${BARRIER_COLL} --setenv bindir=${CMAKE_BINARY_DIR}/teshsuite/smpi/barrier --cd ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/barrier barrier_coll.tesh) ENDFOREACH() # END TESH TESTS IF(enable_smpi_MPICH3_testsuite) ADD_TEST(test-smpi-mpich3-coll-thread ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:thread -execarg=--cfg=smpi/privatize_global_variables:yes) ADD_TEST(test-smpi-mpich3-coll-ompi-thread ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:thread -execarg=--cfg=smpi/coll_selector:ompi -execarg=--cfg=smpi/send_is_detached_thres:0 -execarg=--cfg=smpi/privatize_global_variables:yes) ADD_TEST(test-smpi-mpich3-coll-mpich-thread ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:thread -execarg=--cfg=smpi/coll_selector:mpich -execarg=--cfg=smpi/privatize_global_variables:yes) SET_TESTS_PROPERTIES(test-smpi-mpich3-coll-thread test-smpi-mpich3-coll-ompi-thread test-smpi-mpich3-coll-mpich-thread PROPERTIES PASS_REGULAR_EXPRESSION "tests passed!") IF(CONTEXT_UCONTEXT) ADD_TEST(test-smpi-mpich3-coll-ompi-ucontext ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:ucontext -execarg=--cfg=smpi/coll_selector:ompi -execarg=--cfg=smpi/send_is_detached_thres:0 -execarg=--cfg=smpi/privatize_global_variables:yes) SET_TESTS_PROPERTIES(test-smpi-mpich3-coll-ompi-ucontext PROPERTIES PASS_REGULAR_EXPRESSION "tests passed!") ENDIF() IF(HAVE_RAWCTX) ADD_TEST(test-smpi-mpich3-coll-mpich-raw ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:raw -execarg=--cfg=smpi/coll_selector:mpich -execarg=--cfg=smpi/privatize_global_variables:yes) SET_TESTS_PROPERTIES(test-smpi-mpich3-coll-mpich-raw PROPERTIES PASS_REGULAR_EXPRESSION "tests passed!") ENDIF() IF(HAVE_RAWCTX) ADD_TEST(test-smpi-mpich3-attr-raw ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/attr perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/attr -tests=testlist -execarg=--cfg=contexts/factory:raw) ADD_TEST(test-smpi-mpich3-comm-raw ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/comm perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/comm -tests=testlist -execarg=--cfg=contexts/factory:raw) ADD_TEST(test-smpi-mpich3-init-raw ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/init perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/init -tests=testlist -execarg=--cfg=contexts/factory:raw) ADD_TEST(test-smpi-mpich3-datatype-raw ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/datatype perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/datatype -tests=testlist -execarg=--cfg=contexts/factory:raw) ADD_TEST(test-smpi-mpich3-group-raw ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/group perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/group -tests=testlist -execarg=--cfg=contexts/factory:raw) ADD_TEST(test-smpi-mpich3-pt2pt-raw ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/pt2pt perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/pt2pt -tests=testlist -execarg=--cfg=contexts/factory:raw) ADD_TEST(test-smpi-mpich3-topo-raw ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/topo perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/topo -tests=testlist -execarg=--cfg=contexts/factory:raw) SET_TESTS_PROPERTIES(test-smpi-mpich3-attr-raw test-smpi-mpich3-comm-raw test-smpi-mpich3-init-raw test-smpi-mpich3-datatype-raw test-smpi-mpich3-group-raw test-smpi-mpich3-pt2pt-raw test-smpi-mpich3-topo-raw PROPERTIES PASS_REGULAR_EXPRESSION "tests passed!") ENDIF() IF(SMPI_F2C) ADD_TEST(test-smpi-mpich3-thread-f77 ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/f77/ perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f77/ -tests=testlist -execarg=--cfg=contexts/stack_size:8000 -execarg=--cfg=smpi/privatize_global_variables:yes) SET_TESTS_PROPERTIES(test-smpi-mpich3-thread-f77 PROPERTIES PASS_REGULAR_EXPRESSION "tests passed!") ENDIF() IF(SMPI_F90) ADD_TEST(test-smpi-mpich3-thread-f90 ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/f90/ perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/f90/ -tests=testlist -execarg=--cfg=smpi/privatize_global_variables:yes) SET_TESTS_PROPERTIES(test-smpi-mpich3-thread-f90 PROPERTIES PASS_REGULAR_EXPRESSION "tests passed!") ENDIF() ENDIF() # BEGIN TESH TESTS ADD_TESH_FACTORIES(smpi-energy "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/smpi/energy --cd ${CMAKE_BINARY_DIR}/examples/smpi/energy ${CMAKE_HOME_DIRECTORY}/examples/smpi/energy/energy.tesh) IF(SMPI_F2C) ADD_TESH_FACTORIES(smpi-energy-f77 "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/smpi/energy --cd ${CMAKE_BINARY_DIR}/examples/smpi/energy ${CMAKE_HOME_DIRECTORY}/examples/smpi/energy/f77/energy.tesh) ENDIF() IF(SMPI_F90) ADD_TESH_FACTORIES(smpi-energy-f90 "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/smpi/energy --cd ${CMAKE_BINARY_DIR}/examples/smpi/energy ${CMAKE_HOME_DIRECTORY}/examples/smpi/energy/f90/energy.tesh) ENDIF() ADD_TESH_FACTORIES(smpi-msg-masterslave "thread;ucontext;raw" --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/smpi/smpi_msg_masterslave --cd ${CMAKE_BINARY_DIR}/examples/smpi/smpi_msg_masterslave ${CMAKE_HOME_DIRECTORY}/examples/smpi/smpi_msg_masterslave/msg_smpi.tesh) IF(HAVE_TRACING) ADD_TESH(smpi-tracing-ptp --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/smpi --cd ${CMAKE_BINARY_DIR}/examples/smpi ${CMAKE_HOME_DIRECTORY}/examples/smpi/tracing/smpi_traced.tesh) ADD_TESH(smpi-replay --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/smpi --cd ${CMAKE_BINARY_DIR}/examples/smpi ${CMAKE_HOME_DIRECTORY}/examples/smpi/replay/smpi_replay.tesh) ENDIF() # END TESH TESTS ENDIF() ## BINGINGS ## ### LUA ### # BEGIN TESH TESTS IF(HAVE_LUA) ADD_TESH(lua-duplicated-globals --cd ${CMAKE_HOME_DIRECTORY}/examples/lua/state_cloner duplicated_globals.tesh) ADD_TESH(lua-masterslave --cd ${CMAKE_HOME_DIRECTORY}/examples/lua/masterslave master_slave.tesh) ADD_TESH(lua-mult-matrix --cd ${CMAKE_HOME_DIRECTORY}/examples/lua/multi_matrix mult_matrix.tesh) ADD_TESH(lua-masterslave-bypass --cd ${CMAKE_HOME_DIRECTORY}/examples/lua/console master_slave_bypass.tesh) ADD_TESH(lua-chord --cd ${CMAKE_HOME_DIRECTORY}/examples/lua/chord chord.tesh) ADD_TESH(lua-bittorrent --cd ${CMAKE_HOME_DIRECTORY}/examples/lua/bittorrent bittorrent.tesh) ADD_TESH(lua-kademlia --cd ${CMAKE_HOME_DIRECTORY}/examples/lua/kademlia kademlia.tesh) SET_TESTS_PROPERTIES(lua-duplicated-globals PROPERTIES ENVIRONMENT "LUA_CPATH=${CMAKE_BINARY_DIR}/examples/lua/?.so") SET_TESTS_PROPERTIES(lua-masterslave PROPERTIES ENVIRONMENT "LUA_CPATH=${CMAKE_BINARY_DIR}/examples/lua/?.so") SET_TESTS_PROPERTIES(lua-mult-matrix PROPERTIES ENVIRONMENT "LUA_CPATH=${CMAKE_BINARY_DIR}/examples/lua/?.so") SET_TESTS_PROPERTIES(lua-masterslave-bypass PROPERTIES ENVIRONMENT "LUA_CPATH=${CMAKE_BINARY_DIR}/examples/lua/?.so") SET_TESTS_PROPERTIES(lua-chord PROPERTIES ENVIRONMENT "LUA_CPATH=${CMAKE_BINARY_DIR}/examples/lua/?.so") SET_TESTS_PROPERTIES(lua-bittorrent PROPERTIES ENVIRONMENT "LUA_CPATH=${CMAKE_BINARY_DIR}/examples/lua/?.so") SET_TESTS_PROPERTIES(lua-kademlia PROPERTIES ENVIRONMENT "LUA_CPATH=${CMAKE_BINARY_DIR}/examples/lua/?.so") ENDIF() # END TESH TESTS ### JAVA ### IF(enable_java) IF(WIN32) SET(TESH_CLASSPATH "${CMAKE_BINARY_DIR}/examples/java/\;${SIMGRID_FULL_JAR}") STRING(REPLACE "\;" "§" TESH_CLASSPATH "${TESH_CLASSPATH}") ELSE() SET(TESH_CLASSPATH "${CMAKE_BINARY_DIR}/examples/java/:${SIMGRID_FULL_JAR}") ENDIF() ADD_TESH(java-async --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/async/async.tesh) ADD_TESH(java-bittorrent --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/bittorrent/bittorrent.tesh) ADD_TESH(java-bypass --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/master_slave_bypass/bypass.tesh) ADD_TESH(java-chord --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/chord/chord.tesh) ADD_TESH(java-cloud --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/cloud/cloud.tesh) ADD_TESH(java-cloud-migration --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/cloud/migration/migration.tesh) ADD_TESH(java-commTime --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/commTime/commtime.tesh) ADD_TESH(java-kademlia --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/kademlia/kademlia.tesh) ADD_TESH(java-kill --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/master_slave_kill/kill.tesh) ADD_TESH(java-masterslave --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/masterslave/masterslave.tesh) ADD_TESH(java-migration --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/migration/migration.tesh) ADD_TESH(java-mutualExclusion --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/mutualExclusion/mutualexclusion.tesh) ADD_TESH(java-pingPong --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/pingPong/pingpong.tesh) ADD_TESH(java-priority --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/priority/priority.tesh) ADD_TESH(java-reservation-surf-plugin --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/reservationSurfPlugin/reservation_surf_plugin.tesh) ADD_TESH(java-startKillTime --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/startKillTime/startKillTime.tesh) ADD_TESH(java-surf-cpu-model --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/surfCpuModel/surf_cpu_model.tesh) ADD_TESH(java-surf-plugin --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/surfPlugin/surf_plugin.tesh) ADD_TESH(java-suspend --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/suspend/suspend.tesh) IF(HAVE_TRACING) ADD_TESH(java-tracing --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/java --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/java ${CMAKE_HOME_DIRECTORY}/examples/java/tracing/tracingPingPong.tesh) ENDIF() ENDIF() ### SCALA ### IF(enable_scala) IF(WIN32) SET(TESH_CLASSPATH "${CMAKE_BINARY_DIR}/examples/scala/\;${SIMGRID_FULL_JAR}\;${SCALA_JARS}") STRING(REPLACE "\;" "§" TESH_CLASSPATH "${TESH_CLASSPATH}") ELSE() SET(TESH_CLASSPATH "${CMAKE_BINARY_DIR}/examples/scala/:${SIMGRID_FULL_JAR}:${SCALA_JARS}") ENDIF() ADD_TESH(scala-bypass --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/scala --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/scala ${CMAKE_HOME_DIRECTORY}/examples/scala/master_slave_bypass/bypass.tesh) ADD_TESH(scala-kill --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/scala --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/scala ${CMAKE_HOME_DIRECTORY}/examples/scala/master_slave_kill/kill.tesh) ADD_TESH(scala-masterslave --setenv srcdir=${CMAKE_HOME_DIRECTORY}/examples/scala --setenv classpath=${TESH_CLASSPATH} --cd ${CMAKE_BINARY_DIR}/examples/scala ${CMAKE_HOME_DIRECTORY}/examples/scala/masterslave/masterslave.tesh) ENDIF() ENDIF() ## OTHER ## ADD_TEST(testall ${CMAKE_BINARY_DIR}/src/testall) IF(enable_auto_install) ADD_TEST(simgrid_install make install) ENDIF() IF(enable_memcheck) INCLUDE(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/memcheck_tests.cmake) ENDIF() SimGrid-3.11/buildtools/Cmake/test_prog/000755 001750 001750 00000000000 12342443653 017240 5ustar00cici000000 000000 SimGrid-3.11/buildtools/Cmake/test_prog/prog_gtnets.cpp000644 001750 001750 00000000556 12342443653 022305 0ustar00cici000000 000000 /* Copyright (c) 2010, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include int main(){ Simulator s; s.RunUntilNextCompletion(); } SimGrid-3.11/buildtools/Cmake/test_prog/prog_sem_timedwait.c000644 001750 001750 00000000600 12342443653 023262 0ustar00cici000000 000000 /* Copyright (c) 2010, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include int main() { sem_t *s; const struct timespec *t; sem_timedwait(s, t); } SimGrid-3.11/buildtools/Cmake/test_prog/prog_snprintf.c000644 001750 001750 00000001201 12342443653 022270 0ustar00cici000000 000000 /* Copyright (c) 2010, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include int main(void) { char bufs[5] = { 'x', 'x', 'x', '\0', '\0' }; char bufd[5] = { 'x', 'x', 'x', '\0', '\0' }; int i; i = snprintf(bufs, 2, "%s", "111"); if (strcmp(bufs, "1")) exit(1); if (i != 3) exit(1); i = snprintf(bufd, 2, "%d", 111); if (strcmp(bufd, "1")) exit(1); if (i != 3) exit(1); exit(0); } SimGrid-3.11/buildtools/Cmake/test_prog/prog_vsnprintf.c000644 001750 001750 00000001501 12342443653 022461 0ustar00cici000000 000000 /* Copyright (c) 2010, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include int my_vsnprintf(char *buf, const char *tmpl, ...) { int i; va_list args; va_start(args, tmpl); i = vsnprintf(buf, 2, tmpl, args); va_end(args); return i; } int main(void) { char bufs[5] = { 'x', 'x', 'x', '\0', '\0' }; char bufd[5] = { 'x', 'x', 'x', '\0', '\0' }; int i; i = my_vsnprintf(bufs, "%s", "111"); if (strcmp(bufs, "1")) exit(1); if (i != 3) exit(1); i = my_vsnprintf(bufd, "%d", 111); if (strcmp(bufd, "1")) exit(1); if (i != 3) exit(1); exit(0); } SimGrid-3.11/buildtools/Cmake/test_prog/prog_printf_null.c000644 001750 001750 00000000501 12342443653 022763 0ustar00cici000000 000000 /* Copyright (c) 2010, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include printf("%s", NULL); SimGrid-3.11/buildtools/Cmake/test_prog/prog_sem_init.c000644 001750 001750 00000000712 12342443653 022242 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include #include int main(void) { sem_t s; if (sem_init(&s, 0, 0) != 0) return 1; return 0; } SimGrid-3.11/buildtools/Cmake/test_prog/prog_stackgrowth.c000644 001750 001750 00000001310 12342443653 022766 0ustar00cici000000 000000 /* Copyright (c) 2010, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include static int iterate = 10; static int growsdown(int *x) { auto int y; y = (x > &y); if (--iterate > 0) y = growsdown(&y); if (y != (x > &y)) exit(1); return y; } int main(int argc, char *argv[]) { FILE *f; auto int x; if ((f = fopen("conftestval", "w")) == NULL) exit(1); fprintf(f, "%s\n", growsdown(&x) ? "down" : "up");; fclose(f); exit(0); return 1; } SimGrid-3.11/buildtools/Cmake/test_prog/prog_gnu_dynlinker.c000644 001750 001750 00000001760 12342443653 023307 0ustar00cici000000 000000 /* prog_gnu_dynlinker.c -- check that RTLD_NEXT is defined as in GNU linker */ /* Copyright (c) 2012-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #define _GNU_SOURCE 1 #include #include #include #include static void * (*real_malloc) (size_t); int main(void) { char *error; dlerror(); // clear any previous error real_malloc = (void * (*) (size_t)) dlsym(RTLD_NEXT, "malloc"); error = dlerror(); if (!error && real_malloc) { char *A = real_malloc(20); strcpy(A,"epic success"); free(A); return 0; // SUCCESS } else { if (error) printf("Error while checking for dlsym: %s\n",error); else printf("dlsym did not return any error, but failed to find malloc()\n"); return 1; // FAILED } } SimGrid-3.11/buildtools/Cmake/test_prog/prog_sem_open.c000644 001750 001750 00000001255 12342443653 022243 0ustar00cici000000 000000 /* Copyright (c) 2010-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #include #include #include #ifndef SEM_FAILED #define SEM_FAILED (-1) #endif int main(void) { #ifdef WIN32 int s; #else sem_t * s; #endif s = sem_open("/0", O_CREAT, 0644, 10); if (s == SEM_FAILED){ // printf("sem_open failed\n"); return 1; } // printf("sem_open succeeded\n"); return 0; } SimGrid-3.11/buildtools/Cmake/test_prog/prog_AC_CHECK_MCSC.c000644 001750 001750 00000002567 12342443653 022432 0ustar00cici000000 000000 /* Copyright (c) 2010, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include #include #ifdef _XBT_WIN32 #include "xbt/win32_ucontext.h" #include "win32_ucontext.c" #else #include #endif void child(void); ucontext_t uc_child; ucontext_t uc_main; void child(void) { if (swapcontext(&uc_child, &uc_main) != 0) exit(2); } int main(int argc, char *argv[]) { FILE *fp; void *stack; /* the default is that it fails */ if ((fp = fopen("conftestval", "w")) == NULL) exit(3); fprintf(fp, "no\n"); fclose(fp); /* configure a child user-space context */ if ((stack = malloc(64 * 1024)) == NULL) exit(4); if (getcontext(&uc_child) != 0) exit(5); uc_child.uc_link = NULL; uc_child.uc_stack.ss_sp = (char *) stack + (32 * 1024); uc_child.uc_stack.ss_size = 32 * 1024; uc_child.uc_stack.ss_flags = 0; makecontext(&uc_child, child, 0); /* switch into the user context */ if (swapcontext(&uc_main, &uc_child) != 0) exit(6); /* Fine, child came home */ if ((fp = fopen("conftestval", "w")) == NULL) exit(7); fprintf(fp, "yes\n"); fclose(fp); /* die successfully */ exit(0); return 1; } SimGrid-3.11/buildtools/Cmake/test_prog/prog_mutex_timedlock.c000644 001750 001750 00000000642 12342443653 023632 0ustar00cici000000 000000 /* Copyright (c) 2010-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include int main(void) { pthread_mutex_t s; const struct timespec t; sem_timedlock(&s, &t); return 0; } SimGrid-3.11/buildtools/Cmake/test_prog/prog_stacksetup.c000644 001750 001750 00000007171 12342443653 022627 0ustar00cici000000 000000 /* Copyright (c) 2010, 2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #if defined OSX #define _XOPEN_SOURCE #endif #ifdef _XBT_WIN32 #include "xbt/win32_ucontext.h" #include "win32_ucontext.c" #endif #include #include #include #if defined(TEST_sigstack) || defined(TEST_sigaltstack) #include #include #include #endif #if defined(TEST_makecontext) #ifdef _XBT_WIN32 #include "xbt/win32_ucontext.h" #else #include #endif #endif union alltypes { long l; double d; void *vp; void (*fp) (void); char *cp; }; static volatile char *handler_addr = (char *) 0xDEAD; #if defined(TEST_sigstack) || defined(TEST_sigaltstack) static volatile int handler_done = 0; void handler(int sig) { char garbage[1024]; int i; auto int dummy; for (i = 0; i < 1024; i++) garbage[i] = 'X'; handler_addr = (char *) &dummy; handler_done = 1; return; } #endif #if defined(TEST_makecontext) static ucontext_t uc_handler; static ucontext_t uc_main; void handler(void) { char garbage[1024]; int i; auto int dummy; for (i = 0; i < 1024; i++) garbage[i] = 'X'; handler_addr = (char *) &dummy; swapcontext(&uc_handler, &uc_main); return; } #endif int main(int argc, char *argv[]) { FILE *f; char *skaddr; char *skbuf; int sksize; char result[1024]; int i; sksize = 32768; skbuf = (char *) malloc(sksize * 2 + 2 * sizeof(union alltypes)); if (skbuf == NULL) exit(1); for (i = 0; i < sksize * 2 + 2 * sizeof(union alltypes); i++) skbuf[i] = 'A'; skaddr = skbuf + sizeof(union alltypes); #if defined(TEST_sigstack) || defined(TEST_sigaltstack) { struct sigaction sa; #if defined(TEST_sigstack) struct sigstack ss; #elif defined(TEST_sigaltstack) && defined(HAVE_STACK_T) stack_t ss; #else struct sigaltstack ss; #endif #if defined(TEST_sigstack) ss.ss_sp = (void *) (skaddr + sksize); ss.ss_onstack = 0; if (sigstack(&ss, NULL) < 0) exit(1); #elif defined(TEST_sigaltstack) ss.ss_sp = (void *) (skaddr + sksize); ss.ss_size = sksize; ss.ss_flags = 0; if (sigaltstack(&ss, NULL) < 0) exit(1); #endif memset((void *) &sa, 0, sizeof(struct sigaction)); sa.sa_handler = handler; sa.sa_flags = SA_ONSTACK; sigemptyset(&sa.sa_mask); sigaction(SIGUSR1, &sa, NULL); kill(getpid(), SIGUSR1); while (!handler_done) /*nop */ ; } #endif #if defined(TEST_makecontext) { if (getcontext(&uc_handler) != 0) exit(1); uc_handler.uc_link = NULL; uc_handler.uc_stack.ss_sp = (void *) (skaddr + sksize); uc_handler.uc_stack.ss_size = sksize; uc_handler.uc_stack.ss_flags = 0; makecontext(&uc_handler, handler, 0); swapcontext(&uc_main, &uc_handler); } #endif if (handler_addr == (char *) 0xDEAD) exit(1); if (handler_addr < skaddr + sksize) { /* stack was placed into lower area */ if (*(skaddr + sksize) != 'A') sprintf(result, "(skaddr)+(sksize)-%d,(sksize)-%d", sizeof(union alltypes), sizeof(union alltypes)); else strcpy(result, "(skaddr)+(sksize),(sksize)"); } else { /* stack was placed into higher area */ if (*(skaddr + sksize * 2) != 'A') sprintf(result, "(skaddr),(sksize)-%d", sizeof(union alltypes)); else strcpy(result, "(skaddr),(sksize)"); } if ((f = fopen("conftestval", "w")) == NULL) exit(1); fprintf(f, "%s\n", result); fclose(f); exit(0); return 1; } SimGrid-3.11/buildtools/Cmake/test_prog/prog_thread_storage.c000644 001750 001750 00000000716 12342443653 023432 0ustar00cici000000 000000 /* Copyright (c) 2010-2011, 2013-2014. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ #include __thread int thread_specific_variable = 0; int main(void) { thread_specific_variable++; printf("%d\n", thread_specific_variable); return 0; } SimGrid-3.11/buildtools/Cmake/PrintArgs.cmake000644 001750 001750 00000016620 12342443653 020152 0ustar00cici000000 000000 if(enable_print_message) message("") message("______________________________________________________________________") message("______________________________________________________________________ DEBUG") message("CMAKE_HOME_DIRECTORY ........: ${CMAKE_HOME_DIRECTORY}") message("") message("SIZEOF_MAX ..................: ${SIZEOF_MAX}") message("PTH_STACKGROWTH .............: ${PTH_STACKGROWTH}") message("need_asprintf ...............: ${simgrid_need_asprintf}") message("need_vasprintf ..............: ${simgrid_need_vasprintf}") message("PREFER_PORTABLE_SNPRINTF ....: ${PREFER_PORTABLE_SNPRINTF}") message("HAVE_VA_COPY ................: ${HAVE_VA_COPY}") message("PRINTF_NULL_WORKING .........: ${PRINTF_NULL_WORKING}") message("") message("\#define pth_skaddr_makecontext(skaddr,sksize) (${makecontext_addr})") message("\#define pth_sksize_makecontext(skaddr,sksize) (${makecontext_size})") message("\#define __VA_COPY_USE ${__VA_COPY_USE}") message("mcsc ........................: ${mcsc}") message("") message("HAVE_PTHREAD_CREATE .........: ${pthread}") message("HAVE_SEM_INIT ...............: ${HAVE_SEM_INIT_LIB}") message("HAVE_SEM_TIMEDWAIT ..........: ${HAVE_SEM_TIMEDWAIT_LIB}") message("HAVE_MUTEX_TIMEDLOCK ........: ${HAVE_MUTEX_TIMEDLOCK_LIB}") message("HAVE_POSIX_GETTIME ..........: ${HAVE_POSIX_GETTIME}") message("") message("TIME_WITH_SYS_TIME ..........: ${TIME_WITH_SYS_TIME}") message("STDC_HEADERS ................: ${STDC_HEADERS}") message("HAVE_PTHREAD_H ..............: ${HAVE_PTHREAD_H}") message("HAVE_VALGRIND_VALGRIND_H ....: ${HAVE_VALGRIND_VALGRIND_H}") message("HAVE_SOCKET_H ...............: ${HAVE_SOCKET_H}") message("HAVE_SYS_SOCKET_H ...........: ${HAVE_SYS_SOCKET_H}") message("HAVE_STAT_H .................: ${HAVE_STAT_H}") message("HAVE_SYS_STAT_H .............: ${HAVE_SYS_STAT_H}") message("HAVE_WINDOWS_H ..............: ${HAVE_WINDOWS_H}") message("HAVE_WINSOCK_H ..............: ${HAVE_WINSOCK_H}") message("HAVE_WINSOCK2_H .............: ${HAVE_WINSOCK2_H}") message("HAVE_ERRNO_H ................: ${HAVE_ERRNO_H}") message("HAVE_UNISTD_H ...............: ${HAVE_UNISTD_H}") message("HAVE_EXECINFO_H .............: ${HAVE_EXECINFO_H}") message("HAVE_SIGNAL_H ...............: ${HAVE_SIGNAL_H}") message("HAVE_SYS_TIME_H .............: ${HAVE_SYS_TIME_H}") message("HAVE_TIME_H .................: ${HAVE_TIME_H}") message("HAVE_DLFCN_H ................: ${HAVE_DLFCN_H}") message("HAVE_INTTYPES_H .............: ${HAVE_INTTYPES_H}") message("HAVE_MEMORY_H ...............: ${HAVE_MEMORY_H}") message("HAVE_STDLIB_H ...............: ${HAVE_STDLIB_H}") message("HAVE_STRINGS_H ..............: ${HAVE_STRINGS_H}") message("HAVE_STRING_H ...............: ${HAVE_STRING_H}") message("HAVE_STDIO_H ................: ${HAVE_STDIO_H}") message("") message("HAVE_GETTIMEOFDAY ...........: ${HAVE_GETTIMEOFDAY}") message("HAVE_NANOSLEEP ..............: ${HAVE_NANOSLEEP}") message("HAVE_GETDTABLESIZE ..........: ${HAVE_GETDTABLESIZE}") message("HAVE_SYSCONF ................: ${HAVE_SYSCONF}") message("HAVE_READV ..................: ${HAVE_READV}") message("HAVE_POPEN ..................: ${HAVE_POPEN}") message("HAVE_SIGNAL .................: ${HAVE_SIGNAL}") message("HAVE_MAKECONTEXT ............: ${HAVE_MAKECONTEXT}") message("HAVE_SNPRINTF ...............: ${HAVE_SNPRINTF}") message("HAVE_VSNPRINTF ..............: ${HAVE_VSNPRINTF}") message("HAVE_ASPRINTF ...............: ${HAVE_ASPRINTF}") message("HAVE_VASPRINTF ..............: ${HAVE_VASPRINTF}") message("HAVE_MMAP ...................: ${HAVE_MMAP}") message("HAVE_THREAD_LOCAL_STORAGE ...: ${HAVE_THREAD_LOCAL_STORAGE}") message("HAVE_MMALLOC ................: ${HAVE_MMALLOC}") message("") message("CONTEXT_THREADS .............: ${CONTEXT_THREADS}") message("CONTEXT_UCONTEXT ............: ${CONTEXT_UCONTEXT}") message("______________________________________________________________________") message("______________________________________________________________________ DEBUG END") message("") endif() message("\nConfiguration of package `simgrid':") message(" BUILDNAME ...........: ${BUILDNAME}") message(" SITE ................: ${SITE}") if(release) message(" Release .............: simgrid-${release_version}${SIMGRID_VERSION_EXTRA} (release build)") else() message(" Release .............: simgrid-${release_version}${SIMGRID_VERSION_EXTRA} (development build)") endif() message("") message(" Compiler: C .........: ${CMAKE_C_COMPILER} (${CMAKE_C_COMPILER_ID})") message(" version .....: ${COMPILER_C_VERSION}") if(CMAKE_CXX_COMPILER) message(" Compiler: C++ .......: ${CMAKE_CXX_COMPILER} (${CMAKE_CXX_COMPILER_ID})") message(" version .....: ${COMPILER_CXX_VERSION}") endif() if(CMAKE_Java_COMPILER) message(" Compiler: Java ......: ${CMAKE_Java_COMPILER} (${CMAKE_Java_COMPILER_ID})") message(" version .....: ${COMPILER_Java_VERSION}") endif() if(CMAKE_Fortran_COMPILER) message(" Compiler: Fortran ...: ${CMAKE_Fortran_COMPILER} (${CMAKE_Fortran_COMPILER_ID})") message(" version .....: ${COMPILER_Fortran_VERSION}") endif() message(" Linker: .............: ${CMAKE_LINKER}") message("") message(" CFlags ..............: ${CMAKE_C_FLAGS}") message(" CXXFlags ............: ${CMAKE_CXX_FLAGS}") message(" LDFlags .............: ${CMAKE_C_LINK_FLAGS}") message("") if(NOT APPLE AND NOT WIN32) message(" Compile Gtnets ......: ${HAVE_GTNETS}") message(" Compile NS-3 ........: ${HAVE_NS3}") message(" Gtnets path .........: ${gtnets_path}") message(" NS-3 path ...........: ${ns3_path}") endif() message(" Compile Java ........: ${HAVE_Java}") message(" Compile Scala........: ${HAVE_Scala}") message(" Compile Lua .........: ${HAVE_LUA}") message(" Compile Smpi ........: ${HAVE_SMPI}") message(" Compile MPI testsuite: ${enable_smpi_MPICH3_testsuite}") message(" Compile Smpi f77 ....: ${SMPI_F2C}") message(" Compile Smpi f90 ....: ${SMPI_F90}") message(" Compile Static ......: ${enable_lib_static}") if(enable_java) message(" Native lib in jar ...: ${enable_lib_in_jar}") endif() message("") message(" Maintainer mode .....: ${enable_maintainer_mode}") message(" Model checking ......: ${HAVE_MC}") message(" Tracing mode ........: ${enable_tracing}") message(" Jedule mode ........: ${enable_jedule}") message(" Latency bound .......: ${enable_latency_bound_tracking}") message(" Graphviz mode .......: ${HAVE_GRAPHVIZ}") message(" Sigc++ mode .........: ${HAVE_LIBSIGC++}") message(" Mallocators .........: ${enable_mallocators}") message("") message(" Simgrid dependencies : ${SIMGRID_DEP}") message("") message(" INSTALL_PREFIX ......: ${CMAKE_INSTALL_PREFIX}") exec_program("${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/Testing/Notes/" OUTPUT_VARIABLE OKIDOKI) file(WRITE ${PROJECT_BINARY_DIR}/Testing/Notes/Build "GIT version : ${GIT_VERSION}\n") file(APPEND ${PROJECT_BINARY_DIR}/Testing/Notes/Build "Release : simgrid-${release_version}\n") file(APPEND ${PROJECT_BINARY_DIR}/Testing/Notes/Build "Pipol user : $ENV{PIPOL_USER}\n") file(APPEND ${PROJECT_BINARY_DIR}/Testing/Notes/Build "Pipol image : $ENV{PIPOL_IMAGE}\n") SimGrid-3.11/buildtools/Cmake/Modules/000755 001750 001750 00000000000 12342443653 016642 5ustar00cici000000 000000 SimGrid-3.11/buildtools/Cmake/Modules/FindLibunwind.cmake000644 001750 001750 00000003304 12342443653 022400 0ustar00cici000000 000000 if(PROCESSOR_x86_64) find_library(PATH_LIBUNWIND_LIB NAMES unwind-x86_64 HINTS $ENV{SIMGRID_LIBUNWIND_LIBRARY_PATH} $ENV{LD_LIBRARY_PATH} $ENV{LIBUNWIND_LIBRARY_PATH} PATH_SUFFIXES lib/ GnuWin32/lib PATHS /opt /opt/local /opt/csw /sw /usr) else() find_library(PATH_LIBUNWIND_LIB NAMES unwind HINTS $ENV{SIMGRID_LIBUNWIND_LIBRARY_PATH} $ENV{LD_LIBRARY_PATH} $ENV{LIBUNWIND_LIBRARY_PATH} PATH_SUFFIXES lib/ GnuWin32/lib PATHS /opt /opt/local /opt/csw /sw /usr) endif() find_path(PATH_LIBUNWIND_H "libunwind.h" HINTS $ENV{SIMGRID_LIBUNWIND_LIBRARY_PATH} $ENV{LD_LIBRARY_PATH} $ENV{LIBUNWIND_LIBRARY_PATH} PATH_SUFFIXES include/ GnuWin32/include PATHS /opt /opt/local /opt/csw /sw /usr) message(STATUS "Looking for libunwind.h") if(PATH_LIBUNWIND_H) message(STATUS "Looking for libunwind.h - found") else() message(STATUS "Looking for libunwind.h - not found") endif() message(STATUS "Looking for libunwind") if(PATH_LIBUNWIND_LIB) message(STATUS "Looking for libunwind - found") else() message(STATUS "Looking for libunwind - not found") endif() if(PATH_LIBUNWIND_LIB AND PATH_LIBUNWIND_H) string(REGEX REPLACE "/libunwind.*[.]${LIB_EXE}$" "" PATH_LIBUNWIND_LIB "${PATH_LIBUNWIND_LIB}") string(REGEX REPLACE "/libunwind.h" "" PATH_LIBUNWIND_H "${PATH_LIBUNWIND_H}") include_directories(${PATH_LIBUNWIND_H}) link_directories(${PATH_LIBUNWIND_LIB}) else() message(FATAL_ERROR "Please either install the libunwind7-dev package (or equivalent) or turn off the model-checking option of SimGrid.") endif() mark_as_advanced(PATH_LIBDW_H) mark_as_advanced(PATH_LIBDW_LIB) SimGrid-3.11/buildtools/Cmake/Modules/FindGraphviz.cmake000644 001750 001750 00000007423 12342443653 022245 0ustar00cici000000 000000 find_path(HAVE_CGRAPH_H cgraph.h HINTS $ENV{LD_LIBRARY_PATH} PATH_SUFFIXES include/graphviz include PATHS /opt /opt/local /opt/csw /sw /usr ) find_path(HAVE_AGRAPH_H agraph.h HINTS $ENV{LD_LIBRARY_PATH} PATH_SUFFIXES include/graphviz include PATHS /opt /opt/local /opt/csw /sw /usr ) find_path(HAVE_GRAPH_H graph.h HINTS $ENV{LD_LIBRARY_PATH} PATH_SUFFIXES include/graphviz include PATHS /opt /opt/local /opt/csw /sw /usr ) find_library(HAVE_CGRAPH_LIB NAME cgraph HINTS $ENV{LD_LIBRARY_PATH} PATH_SUFFIXES lib/graphviz lib PATHS /opt /opt/local /opt/csw /sw /usr ) find_library(HAVE_AGRAPH_LIB NAME agraph HINTS $ENV{LD_LIBRARY_PATH} PATH_SUFFIXES lib/graphviz lib PATHS /opt /opt/local /opt/csw /sw /usr ) find_library(HAVE_GRAPH_LIB NAME graph HINTS $ENV{LD_LIBRARY_PATH} PATH_SUFFIXES lib/graphviz lib PATHS /opt /opt/local /opt/csw /sw /usr ) find_library(HAVE_CDT_LIB NAME cdt HINTS $ENV{LD_LIBRARY_PATH} PATH_SUFFIXES lib/graphviz lib PATHS /opt /opt/local /opt/csw /sw /usr ) mark_as_advanced(HAVE_AGRAPH_H) mark_as_advanced(HAVE_CGRAPH_H) mark_as_advanced(HAVE_GRAPH_H) mark_as_advanced(HAVE_GRAPH_LIB) mark_as_advanced(HAVE_CGRAPH_LIB) mark_as_advanced(HAVE_AGRAPH_LIB) mark_as_advanced(HAVE_CDT_LIB) ### Initialize of cgraph if(HAVE_CDT_LIB) if(HAVE_CGRAPH_LIB OR HAVE_AGRAPH_LIB) if(HAVE_AGRAPH_LIB) string(REGEX REPLACE "/libagraph.*" "" lib_graphviz ${HAVE_AGRAPH_LIB}) else() if(HAVE_CGRAPH_LIB) string(REGEX REPLACE "/libcgraph.*" "" lib_graphviz ${HAVE_CGRAPH_LIB}) endif() endif() if(HAVE_GRAPH_H OR HAVE_AGRAPH_H OR HAVE_CGRAPH_H) if(HAVE_GRAPH_H) string(REPLACE "/graphviz/graph.h" "" file_graphviz_h ${HAVE_GRAPH_H}) string(REPLACE "/graphviz" "" file_graphviz_h ${file_graphviz_h}) set(GRAPH_H 1) endif() if(HAVE_AGRAPH_H) string(REPLACE "/graphviz/agraph.h" "" file_graphviz_h ${HAVE_AGRAPH_H}) string(REPLACE "/graphviz" "" file_graphviz_h ${file_graphviz_h}) set(AGRAPH_H 1) endif() if(HAVE_CGRAPH_H) string(REPLACE "/graphviz/cgraph.h" "" file_graphviz_h ${HAVE_CGRAPH_H}) string(REPLACE "/graphviz" "" file_graphviz_h ${file_graphviz_h}) set(CGRAPH_H 1) endif() include_directories(${file_graphviz_h} ${file_graphviz_h}/graphviz) link_directories(${lib_graphviz}) set(HAVE_GRAPHVIZ "1") else() set(HAVE_GRAPHVIZ "0") endif() else() set(HAVE_GRAPHVIZ "0") endif() endif() mark_as_advanced(HAVE_GRAPHVIZ) message(STATUS "Looking for agraph.h") if(HAVE_AGRAPH_H) message(STATUS "Looking for agraph.h - found") else() message(STATUS "Looking for agraph.h - not found") endif() message(STATUS "Looking for cgraph.h") if(HAVE_CGRAPH_H) message(STATUS "Looking for cgraph.h - found") else() message(STATUS "Looking for cgraph.h - not found") endif() message(STATUS "Looking for graph.h") if(HAVE_GRAPH_H) message(STATUS "Looking for graph.h - found") else() message(STATUS "Looking for graph.h - not found") endif() message(STATUS "Looking for lib agraph") if(HAVE_AGRAPH_LIB) message(STATUS "Looking for lib agraph - found") else() message(STATUS "Looking for lib agraph - not found") endif() message(STATUS "Looking for lib cgraph") if(HAVE_CGRAPH_LIB) message(STATUS "Looking for lib cgraph - found") else() message(STATUS "Looking for lib cgraph - not found") endif() message(STATUS "Looking for lib graph") if(HAVE_GRAPH_LIB) message(STATUS "Looking for lib graph - found") else() message(STATUS "Looking for lib graph - not found") endif() message(STATUS "Looking for lib cdt") if(HAVE_CDT_LIB) message(STATUS "Looking for lib cdt - found") else() message(STATUS "Looking for lib cdt - not found") endif()SimGrid-3.11/buildtools/Cmake/Modules/FindF2c.cmake000644 001750 001750 00000003660 12342443653 021064 0ustar00cici000000 000000 find_program(F2C_EXE NAME f2c PATH_SUFFIXES bin/ PATHS /opt /opt/local /opt/csw /sw /usr ) if(F2C_EXE) message(STATUS "Looking for bin f2c - found: ${F2C_EXE}") else() message(STATUS "Looking for bin f2c - not found (http://www.netlib.org/f2c/)") endif() find_library(HAVE_F2C_LIB NAME f2c HINTS ENV LD_LIBRARY_PATH PATH_SUFFIXES lib/ PATHS /opt /opt/local /opt/csw /sw /usr ) if(HAVE_F2C_LIB) message(STATUS "Looking for lib f2c - found: ${HAVE_F2C_LIB}") else() message(STATUS "Looking for lib f2c - not found") endif() get_filename_component(F2C_HINT ${HAVE_F2C_LIB} PATH) find_path(HAVE_F2C_H f2c.h HINTS ${F2C_HINT}/.. PATH_SUFFIXES include/ PATHS /opt /opt/local /opt/csw /sw /usr ) if(HAVE_F2C_H) message(STATUS "Looking for f2c.h - found: ${HAVE_F2C_H}") else() message(STATUS "Looking for f2c.h - not found") endif() if(HAVE_F2C_H) set(HAVE_SMPI_F2C_H 1) endif() mark_as_advanced(HAVE_F2C_H) mark_as_advanced(F2C_EXE) mark_as_advanced(HAVE_F2C_LIB) if(HAVE_F2C_LIB) get_filename_component(F2C_LIBRARY_PATH "${HAVE_F2C_LIB}" PATH) file(TO_NATIVE_PATH "${F2C_LIBRARY_PATH}" F2C_LIBRARY_PATH) endif() #Some old versions of 64 bits systems seem to have a different size between C and Fortran Datatypes #Deactivate F2C with these versions, in order to avoid breaking test cases in legacy systems (as Fedora 13) set(COMPILER_OK 1) if(PROCESSOR_x86_64 AND "${CMAKE_SYSTEM}" MATCHES "Linux" AND ${CMAKE_C_COMPILER_ID} STREQUAL "GNU" AND "4.5" STRGREATER "${COMPILER_C_VERSION_MAJOR_MINOR}" ) set(COMPILER_OK 0) message("Your C compiler is a bit old and Fortran support is quite problematic on 64 bit platforms, F2C has been deactivated") endif() set(SMPI_F2C 0) if(HAVE_F2C_H AND F2C_EXE AND HAVE_F2C_LIB AND COMPILER_OK) set(SMPI_F2C 1) endif() if(SMPI_F2C) include_directories(${HAVE_F2C_H}) else() message("-- Fortran 77 support for smpi is disabled.") endif() SimGrid-3.11/buildtools/Cmake/Modules/FindScala.cmake000644 001750 001750 00000000717 12342443653 021475 0ustar00cici000000 000000 find_program(SCALA_COMPILE NAMES scalac PATH_SUFFIXES bin/ PATHS /opt /opt/local /opt/csw /sw /usr ) message(STATUS "Looking for scalac") if(SCALA_COMPILE) message(STATUS "Looking for scalac - found") else() message(STATUS "Looking for scalac - not found") endif() set(SCALA_JARS "/usr/share/java/scala-compiler.jar:/usr/share/java/scala-library.jar:/usr/share/java/scalap.jar:/usr/share/java/scala/jline.jar:/usr/share/java/jansi.jar") SimGrid-3.11/buildtools/Cmake/Modules/FindLibdw.cmake000644 001750 001750 00000002416 12342443653 021511 0ustar00cici000000 000000 find_library(PATH_LIBDW_LIB NAMES dw HINTS $ENV{SIMGRID_LIBDW_LIBRARY_PATH} $ENV{LD_LIBRARY_PATH} $ENV{LIBDW_LIBRARY_PATH} PATH_SUFFIXES lib/ GnuWin32/lib PATHS /opt /opt/local /opt/csw /sw /usr) find_path(PATH_LIBDW_H "elfutils/libdw.h" HINTS $ENV{SIMGRID_LIBDW_LIBRARY_PATH} $ENV{LD_LIBRARY_PATH} $ENV{LIBDW_LIBRARY_PATH} PATH_SUFFIXES include/ GnuWin32/include PATHS /opt /opt/local /opt/csw /sw /usr) message(STATUS "Looking for libdw.h") if(PATH_LIBDW_H) message(STATUS "Looking for libdw.h - found") else() message(STATUS "Looking for libdw.h - not found") endif() message(STATUS "Looking for libdw") if(PATH_LIBDW_LIB) message(STATUS "Looking for libdw - found") else() message(STATUS "Looking for libdw - not found") endif() if(PATH_LIBDW_LIB AND PATH_LIBDW_H) string(REGEX REPLACE "/libdw.*[.]${LIB_EXE}$" "" PATH_LIBDW_LIB "${PATH_LIBDW_LIB}") string(REGEX REPLACE "/libdw.h" "" PATH_LIBDW_H "${PATH_LIBDW_H}") include_directories(${PATH_LIBDW_H}) link_directories(${PATH_LIBDW_LIB}) else() message(FATAL_ERROR "Please either install the libdw-dev package (or equivalent) or turn off the model-checking option of SimGrid.") endif() mark_as_advanced(PATH_LIBDW_H) mark_as_advanced(PATH_LIBDW_LIB) SimGrid-3.11/buildtools/Cmake/Modules/FindRngStream.cmake000644 001750 001750 00000002255 12342443653 022353 0ustar00cici000000 000000 find_path(HAVE_RNGSTREAM_H NAME RngStream.h HINTS $ENV{HOME} PATH_SUFFIXES include PATHS /opt /opt/local /opt/csw /sw /usr ) find_library(HAVE_RNGSTREAM_LIB NAME rngstreams HINTS $ENV{HOME} PATH_SUFFIXES lib64 lib lib32 PATHS /opt /opt/local /opt/csw /sw /usr ) message(STATUS "Looking for RngStream.h") if(HAVE_RNGSTREAM_H) message(STATUS "Looking for RngStream.h - found") string(REGEX MATCH "-I${HAVE_RNGSTREAM_H} " operation "${CMAKE_C_FLAGS}") if(NOT operation) SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}-I${HAVE_RNGSTREAM_H} ") endif() else() message(STATUS "Looking for RngStream.h - not found") endif() message(STATUS "Looking for lib rngstreams") if(HAVE_RNGSTREAM_LIB) message(STATUS "Looking for lib rngstreams - found") string(REGEX REPLACE "/librngstreams.*" "" HAVE_RNGSTREAM_LIB "${HAVE_RNGSTREAM_LIB}") string(REGEX MATCH "-L${HAVE_RNGSTREAM_LIB} " operation "${CMAKE_C_FLAGS}") if(NOT operation) SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}-L${HAVE_RNGSTREAM_LIB} ") endif() else() message(STATUS "Looking for lib rngstreams - not found") endif() mark_as_advanced(HAVE_RNGSTREAM_LIB) mark_as_advanced(HAVE_RNGSTREAM_H)SimGrid-3.11/buildtools/Cmake/Modules/FindValgrind.cmake000644 001750 001750 00000003306 12342443653 022215 0ustar00cici000000 000000 find_program(VALGRIND_EXE NAME valgrind PATH_SUFFIXES bin/ PATHS /opt /opt/local /opt/csw /sw /usr ) if(VALGRIND_EXE) message(STATUS "Found valgrind: ${VALGRIND_EXE}") SET(VALGRIND_COMMAND "${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Scripts/my_valgrind.pl") SET(MEMORYCHECK_COMMAND "${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Scripts/my_valgrind.pl") endif() if(enable_memcheck_xml) SET(VALGRIND_EXTRA_COMMAND_OPTIONS "--xml=yes --xml-file=memcheck_test_%p.memcheck --child-silent-after-fork=yes") endif() if(VALGRIND_EXE) exec_program("${VALGRIND_EXE} --version " OUTPUT_VARIABLE "VALGRIND_VERSION") string(REGEX MATCH "[0-9].[0-9].[0-9]" NEW_VALGRIND_VERSION "${VALGRIND_VERSION}") if(NEW_VALGRIND_VERSION) message(STATUS "Valgrind version: ${NEW_VALGRIND_VERSION}") exec_program("${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Scripts/generate_memcheck_tests.pl ${CMAKE_HOME_DIRECTORY} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/AddTests.cmake > ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/memcheck_tests.cmake" OUTPUT_VARIABLE SHUTT) set(MEMORYCHECK_COMMAND_OPTIONS "--trace-children=yes --trace-children-skip=/usr/bin/*,/bin/* --leak-check=full --show-reachable=yes --track-origins=no --read-var-info=no --num-callers=20 --suppressions=${CMAKE_HOME_DIRECTORY}/tools/simgrid.supp ${VALGRIND_EXTRA_COMMAND_OPTIONS} ") message(STATUS "Valgrind options: ${MEMORYCHECK_COMMAND_OPTIONS}") else() set(enable_memcheck false) message(STATUS "Error: Command valgrind not found --> enable_memcheck autoset to false.") endif() else() set(enable_memcheck false) message(FATAL_ERROR "Command valgrind not found --> enable_memcheck autoset to false.") endif() mark_as_advanced(VALGRIND_EXE) SimGrid-3.11/buildtools/Cmake/Modules/FindLua51Simgrid.cmake000644 001750 001750 00000002310 12342443653 022647 0ustar00cici000000 000000 include(FindLua51) find_program(HAVE_LUA_BIN NAMES lua) mark_as_advanced(HAVE_LUA_BIN) message(STATUS "Looking for lua.h") if(LUA_INCLUDE_DIR) message(STATUS "Looking for lua.h - found") else() message(STATUS "Looking for lua.h - not found") endif() if(HAVE_LUA_BIN) message(STATUS "Found Lua: ${HAVE_LUA_BIN}") endif() set(LIB_LUA_NAME "") foreach(lib_path ${LUA_LIBRARIES}) if(NOT LIB_LUA_NAME) string(REGEX MATCH "liblua.*$" LIB_LUA_NAME "${lib_path}") string(REPLACE ".${LIB_EXE}" "" LIB_LUA_NAME "${LIB_LUA_NAME}") string(REPLACE "lib" "" LIB_LUA_NAME "${LIB_LUA_NAME}") if(LIB_LUA_NAME) string(REPLACE "/lib${LIB_LUA_NAME}.${LIB_EXE}" "" LUA_LIBRARY_DIR ${lib_path}) endif() endif() endforeach(lib_path ${LUA_LIBRARIES}) message(STATUS "Looking for lib lua") if(LUA_LIBRARY_DIR) message(STATUS "Looking for lib lua - found") message(STATUS "Lua version: ${LIB_LUA_NAME}") message(STATUS "Lib path : ${LUA_LIBRARY_DIR}") else() message(STATUS "Looking for lib lua - not found") endif() if(LUA51_FOUND) set(HAVE_LUA 1) include_directories(${LUA_INCLUDE_DIR}) link_directories(${LUA_LIBRARY_DIR}) else() message(STATUS "Warning : Lua need version 5.1") endif() SimGrid-3.11/buildtools/Cmake/Modules/FindLibSigc++.cmake000644 001750 001750 00000003440 12342443653 022110 0ustar00cici000000 000000 find_path(PATH_LIBSIGC++_H "sigc++/sigc++.h" HINTS $ENV{LD_LIBRARY_PATH} PATH_SUFFIXES include/sigc++-2.0/ include/ PATHS /opt /opt/local /opt/csw /sw /usr) find_path(PATH_LIBSIGC++CONFIG_H "sigc++config.h" HINTS $ENV{LD_LIBRARY_PATH} PATH_SUFFIXES lib/x86_64-linux-gnu/sigc++-2.0/include/ include/ PATHS /opt /opt/local /opt/csw /sw /usr) find_library(PATH_LIBSIGC++_LIB NAMES sigc-2.0 HINTS $ENV{LD_LIBRARY_PATH} PATH_SUFFIXES lib/x86_64-linux-gnu/ lib/sigc++/ lib/ PATHS /opt /opt/local /opt/csw /sw /usr) message(STATUS "Looking for sigc++/sigc++.h") if(PATH_LIBSIGC++_H) message(STATUS "Looking for sigc++/sigc++.h - found") else() message(STATUS "Looking for sigc++/sigc++.h - not found") endif() message(STATUS "Looking for sigc++config.h") if(PATH_LIBSIGC++CONFIG_H) message(STATUS "Looking for sigc++config.h - found") else() message(STATUS "Looking for sigc++config.h - not found") endif() message(STATUS "Looking for libsigc++") if(PATH_LIBSIGC++_LIB) message(STATUS "Looking for libsigc++ - found") else() message(STATUS "Looking for libsigc++ - not found") endif() if(PATH_LIBSIGC++_LIB AND PATH_LIBSIGC++_H AND PATH_LIBSIGC++CONFIG_H) string(REGEX REPLACE "/sigc\\+\\+/sigc\\+\\+.h" "" PATH_LIBSIGC++_H "${PATH_LIBSIGC++_H}") string(REGEX REPLACE "/sigc\\+\\+config.h" "" PATH_LIBSIGC++CONFIG_H "${PATH_LIBSIGC++CONFIG_H}") string(REGEX REPLACE "/libsig.*" "" PATH_LIBSIGC++_LIB "${PATH_LIBSIGC++_LIB}") include_directories(${PATH_LIBSIGC++_H}) include_directories(${PATH_LIBSIGC++CONFIG_H}) link_directories(${PATH_LIBSIGC++_LIB}) set(HAVE_LIBSIGC++ "1") else() set(HAVE_LIBSIGC++ "0") endif() mark_as_advanced(PATH_LIBSIGC++_H) mark_as_advanced(PATH_LIBSIGC++CONFIG_H) mark_as_advanced(PATH_LIBSIGC++_LIB) SimGrid-3.11/buildtools/Cmake/Modules/FindGTnets.cmake000644 001750 001750 00000003171 12342443653 021653 0ustar00cici000000 000000 find_library(HAVE_GTNETS_LIB NAME gtnets PATH_SUFFIXES lib64 lib lib64/gtnets lib/gtnets PATHS ${gtnets_path} ) find_path(HAVE_SIMULATOR_H NAME simulator.h PATH_SUFFIXES include include/gtnets PATHS ${gtnets_path} ) string(REPLACE "/libgtnets.${LIB_EXE}" "" GTNETS_LIB_PATH "${HAVE_GTNETS_LIB}") if(HAVE_GTNETS_LIB AND HAVE_SIMULATOR_H) execute_process(COMMAND ${CMAKE_CXX_COMPILER} -I${HAVE_SIMULATOR_H} -lgtnets -L${GTNETS_LIB_PATH} ${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/test_prog/prog_gtnets.cpp OUTPUT_VARIABLE COMPILE_GTNETS_VAR) if(COMPILE_GTNETS_VAR) SET(HAVE_GTNETS 0) else() SET(HAVE_GTNETS 1) string(REGEX MATCH "-L${GTNETS_LIB_PATH} " operation "${CMAKE_C_FLAGS}") if(NOT operation) SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}-L${GTNETS_LIB_PATH} ") endif() SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}-I${HAVE_SIMULATOR_H} -L${GTNETS_LIB_PATH} ") string(REGEX MATCH "${GTNETS_LIB_PATH}" operation "$ENV{LD_LIBRARY_PATH}") if(NOT operation) message(FATAL_ERROR "\n\nTo use GTNETS don't forget to set LD_LIBRARY_PATH with \n\texport LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${GTNETS_LIB_PATH}\n\n") endif() endif() else() if(NOT HAVE_GTNETS_LIB) message(STATUS "Gtnets is enabled but can't find it.") endif() if(NOT HAVE_SIMULATOR_H) message(STATUS "Gtnets needs simulator.h") endif() endif() message(STATUS "Looking for lib gtnets patch") if(HAVE_GTNETS) message(STATUS "Looking for lib gtnets patch - found") else() message(STATUS "Looking for lib gtnets patch - not found") endif() mark_as_advanced(HAVE_GTNETS_LIB) mark_as_advanced(HAVE_SIMULATOR_H)SimGrid-3.11/buildtools/Cmake/Modules/FindNS3.cmake000644 001750 001750 00000004614 12342443653 021055 0ustar00cici000000 000000 # If you use NS-3 version 3.14 (prefer used at most 3.13) be sure having do # ln -sf libns3.14.1-applications-debug.so libns3-applications.so # ln -sf libns3.14.1-internet-debug.so libns3-internet.so # ln -sf libns3.14.1-point-to-point-debug.so libns3-point-to-point.so # ln -sf libns3.14.1-csma-debug.so libns3-csma.so # ln -sf libns3.14.1-core-debug.so libns3-core.so find_library(HAVE_NS3_LIB NAME ns3 PATH_SUFFIXES lib64 lib ns3/lib PATHS ${ns3_path} ) find_library(HAVE_NS3_CORE_LIB NAME ns3-core ns3.14-core ns3.17-core PATH_SUFFIXES lib64 lib ns3/lib PATHS ${ns3_path} ) find_path(HAVE_CORE_MODULE_H NAME ns3/core-module.h PATH_SUFFIXES include ns3/include include/ns3.14.1 include/ns3.17 PATHS ${ns3_path} ) message(STATUS "Looking for core-module.h") if(HAVE_CORE_MODULE_H) message(STATUS "Looking for core-module.h - found") else() message(STATUS "Looking for core-module.h - not found") endif() mark_as_advanced(HAVE_CORE_MODULE_H) message(STATUS "Looking for lib ns3") if(HAVE_NS3_LIB) message(STATUS "Looking for lib ns3 - found") else() message(STATUS "Looking for lib ns3 - not found") endif() mark_as_advanced(HAVE_NS3_LIB) message(STATUS "Looking for lib ns3-core") if(HAVE_NS3_CORE_LIB) message(STATUS "Looking for lib ns3-core - found") else() message(STATUS "Looking for lib ns3-core - not found") endif() mark_as_advanced(HAVE_NS3_LIB) mark_as_advanced(HAVE_NS3_CORE_LIB) if(HAVE_CORE_MODULE_H) if(HAVE_NS3_LIB) message(STATUS "Warning: NS-3 version <= 3.10") set(HAVE_NS3 1) set(NS3_VERSION_MINOR 10) get_filename_component(NS3_LIBRARY_PATH "${HAVE_NS3_LIB}" PATH) endif() if(HAVE_NS3_CORE_LIB) message(STATUS "NS-3 version > 3.10") string(REGEX REPLACE ".*ns3.([0-9]+)-core.*" "\\1" NS3_VERSION_MINOR "${HAVE_NS3_CORE_LIB}") set(HAVE_NS3 1) get_filename_component(NS3_LIBRARY_PATH "${HAVE_NS3_CORE_LIB}" PATH) endif() endif() if(HAVE_NS3) string(REGEX MATCH "${NS3_LIBRARY_PATH}" operation "$ENV{LD_LIBRARY_PATH}") if(NOT operation) message(STATUS "Warning: To use NS-3 don't forget to set LD_LIBRARY_PATH with: export LD_LIBRARY_PATH=${NS3_LIBRARY_PATH}\${LD_LIBRARY_PATH:+:\$LD_LIBRARY_PATH}") endif() link_directories(${NS3_LIBRARY_PATH}) include_directories(${HAVE_CORE_MODULE_H}) else() message(STATUS "Warning: To use NS-3 Please install ns3 at least version 3.10 (http://www.nsnam.org/releases/)") endif() SimGrid-3.11/buildtools/Cmake/Modules/FindGFortran.cmake000644 001750 001750 00000001270 12342443653 022167 0ustar00cici000000 000000 find_program(GFORTRAN_EXE NAME gfortran PATH_SUFFIXES bin/ PATHS /opt /opt/local /opt/csw /sw /usr ) mark_as_advanced(GFORTRAN_EXE) message(STATUS "Looking for bin gfortran") if(GFORTRAN_EXE) message(STATUS "Found gfortran: ${GFORTRAN_EXE}") else() message(STATUS "Looking for bin gfortran - not found") endif() set(SMPI_F90 0) if(GFORTRAN_EXE) if(NOT SMPI_F2C) message("-- Fortran 90 support for smpi also needs f2c.") #elseif(HAVE_MC) # message("-- Fortran 90 support for smpi is currently not compatible with model checking.") else() set(SMPI_F90 1) endif() endif() if(NOT SMPI_F90) message("-- Fortran 90 support for smpi is disabled.") endif() SimGrid-3.11/buildtools/Cmake/Modules/FindSimGrid.cmake000644 001750 001750 00000002701 12342443653 022003 0ustar00cici000000 000000 #IF YOU HAVE INSTALL SIMGRID IN A SPECIAL DIRECTORY #YOU CAN SPECIFY SIMGRID_ROOT # TO CALL THIS FILE USE #set(CMAKE_MODULE_PATH #${CMAKE_MODULE_PATH} #${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Modules #) find_library(HAVE_SIMGRID_LIB NAME simgrid HINTS $ENV{LD_LIBRARY_PATH} $ENV{SIMGRID_ROOT} PATH_SUFFIXES lib64 lib PATHS /opt /opt/local /opt/csw /sw /usr ) find_program(HAVE_TESH NAMES tesh HINTS $ENV{SIMGRID_ROOT} PATH_SUFFIXES bin PATHS /opt /opt/local /opt/csw /sw /usr ) message(STATUS "Looking for lib SimGrid") if(HAVE_SIMGRID_LIB) message(STATUS "Looking for lib SimGrid - found") get_filename_component(simgrid_version ${HAVE_SIMGRID_LIB} REALPATH) string(REPLACE "${HAVE_SIMGRID_LIB}." "" simgrid_version "${simgrid_version}") string(REGEX MATCH "^[0-9]" SIMGRID_MAJOR_VERSION "${simgrid_version}") string(REGEX MATCH "^[0-9].[0-9]" SIMGRID_MINOR_VERSION "${simgrid_version}") string(REGEX MATCH "^[0-9].[0-9].[0-9]" SIMGRID_PATCH_VERSION "${simgrid_version}") string(REGEX REPLACE "^${SIMGRID_MINOR_VERSION}." "" SIMGRID_PATCH_VERSION "${SIMGRID_PATCH_VERSION}") string(REGEX REPLACE "^${SIMGRID_MAJOR_VERSION}." "" SIMGRID_MINOR_VERSION "${SIMGRID_MINOR_VERSION}") message(STATUS "Simgrid version : ${SIMGRID_MAJOR_VERSION}.${SIMGRID_MINOR_VERSION}") else() message(STATUS "Looking for lib SimGrid - not found") endif() if(HAVE_TESH) message(STATUS "Found Tesh: ${HAVE_TESH}") endif() SimGrid-3.11/buildtools/Cmake/Modules/FindRubySimgrid.cmake000644 001750 001750 00000003513 12342443653 022707 0ustar00cici000000 000000 include(FindRuby) if(RUBY_EXECUTABLE) message(STATUS "Found ruby: ${RUBY_EXECUTABLE}") endif() message(STATUS "Looking for ruby.h") if(RUBY_INCLUDE_DIR) message(STATUS "Looking for ruby.h - found") else() message(STATUS "Looking for ruby.h - not found") endif() message(STATUS "Looking for confi.h") if(RUBY_CONFIG_INCLUDE_DIR) message(STATUS "Looking for config.h - found") else() message(STATUS "Looking for config.h - not found") endif() message(STATUS "Looking for lib ruby") if(RUBY_LIBRARY) message(STATUS "Looking for lib ruby - found") else() message(STATUS "Looking for lib ruby - not found") endif() if(RUBY_LIBRARY) set(LIB_RUBY_VERSION "${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.${RUBY_VERSION_PATCH}") message(STATUS "Lib ruby version: ${LIB_RUBY_VERSION}") if(RUBY_VERSION_MAJOR MATCHES "1" AND RUBY_VERSION_MINOR MATCHES "9") string(REGEX MATCH "ruby.*[0-9]" RUBY_LIBRARY_NAME ${RUBY_LIBRARY}) if(NOT RUBY_LIBRARY_NAME) set(RUBY_LIBRARY_NAME ruby) endif() string(REGEX REPLACE "/libruby.*$" "" RUBY_LIBRARY ${RUBY_LIBRARY}) SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}-I${RUBY_CONFIG_INCLUDE_DIR} ") #path to config.h string(COMPARE EQUAL "${RUBY_INCLUDE_DIR}" "${RUBY_CONFIG_INCLUDE_DIR}" operation) if(NOT operation) SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}-I${RUBY_INCLUDE_DIR} ") #path to ruby.h endif() ADD_DEFINITIONS("-I${CMAKE_HOME_DIRECTORY}/src/bindings/ruby -I${CMAKE_HOME_DIRECTORY}/src/simix") SET(HAVE_RUBY 1) else() message(STATUS "Warning: Ruby bindings need version 1.9.x, but found version ${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.x") SET(HAVE_RUBY 0) endif() else() SET(HAVE_RUBY 0) endif() if(NOT RUBY_EXECUTABLE) message(STATUS "Warning: you are missing the ruby executable, so you can compile and build examples but can't execute them!") endif()SimGrid-3.11/buildtools/Cmake/MakeJava.cmake000644 001750 001750 00000013464 12342443653 017723 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.8.6) include(UseJava) # Rules to build libsimgrid-java # add_library(simgrid-java SHARED ${JMSG_C_SRC}) set_target_properties(simgrid-java PROPERTIES VERSION ${libsimgrid-java_version}) if (CMAKE_VERSION VERSION_LESS "2.8.8") include_directories(${JNI_INCLUDE_DIRS}) message(WARNING "[Java] Try to workaround missing feature in older CMake. You should better update CMake to version 2.8.8 or above.") get_directory_property(CHECK_INCLUDES INCLUDE_DIRECTORIES) else() get_target_property(COMMON_INCLUDES simgrid-java INCLUDE_DIRECTORIES) if (COMMON_INCLUDES) set_target_properties(simgrid-java PROPERTIES INCLUDE_DIRECTORIES "${COMMON_INCLUDES};${JNI_INCLUDE_DIRS}") else() set_target_properties(simgrid-java PROPERTIES INCLUDE_DIRECTORIES "${JNI_INCLUDE_DIRS}") endif() add_dependencies(simgrid-java simgrid) get_target_property(CHECK_INCLUDES simgrid-java INCLUDE_DIRECTORIES) endif() message("-- [Java] simgrid-java includes: ${CHECK_INCLUDES}") target_link_libraries(simgrid-java simgrid) if(WIN32) exec_program("java -d32 -version" OUTPUT_VARIABLE IS_32_BITS_JVM) STRING( FIND ${IS_32_BITS_JVM} "Error" POSITION ) if(${POSITION} GREATER -1) message(FATAL_ERROR "Java JVM needs to be 32 bits to be able to run with Simgrid on Windows for now") endif() set_target_properties(simgrid-java PROPERTIES LINK_FLAGS "-Wl,--subsystem,windows,--kill-at" PREFIX "") find_path(PEXPORTS_PATH NAMES pexports.exe PATHS NO_DEFAULT_PATHS) message(STATUS "pexports: ${PEXPORTS_PATH}") if(PEXPORTS_PATH) add_custom_command(TARGET simgrid-java POST_BUILD COMMAND ${PEXPORTS_PATH}/pexports.exe ${CMAKE_BINARY_DIR}/lib/simgrid-java.dll > ${CMAKE_BINARY_DIR}/lib/simgrid-java.def) endif(PEXPORTS_PATH) endif() # Rules to build simgrid.jar # ## Files to include in simgrid.jar ## set(SIMGRID_JAR "${CMAKE_BINARY_DIR}/simgrid.jar") set(SIMGRID_FULL_JAR "${CMAKE_BINARY_DIR}/simgrid_full.jar") set(MANIFEST_IN_FILE "${CMAKE_HOME_DIRECTORY}/src/bindings/java/MANIFEST.MF.in") set(MANIFEST_FILE "${CMAKE_BINARY_DIR}/src/bindings/java/MANIFEST.MF") set(LIBSIMGRID_SO libsimgrid${CMAKE_SHARED_LIBRARY_SUFFIX}) set(LIBSIMGRID_JAVA_SO ${CMAKE_SHARED_LIBRARY_PREFIX}simgrid-java${CMAKE_SHARED_LIBRARY_SUFFIX}) set(LIBSURF_JAVA_SO ${CMAKE_SHARED_LIBRARY_PREFIX}surf-java${CMAKE_SHARED_LIBRARY_SUFFIX}) ## Don't strip libraries if not in release mode ## if(release) set(STRIP_COMMAND "${CMAKE_STRIP}") else() set(STRIP_COMMAND "true") endif() ## Here is how to build simgrid.jar ## if(CMAKE_VERSION VERSION_LESS "2.8.12") set(CMAKE_JAVA_TARGET_OUTPUT_NAME simgrid) add_jar(simgrid-java_pre_jar ${JMSG_JAVA_SRC} ${JSURF_JAVA_GENERATED_SRC}) else() add_jar(simgrid-java_pre_jar ${JMSG_JAVA_SRC} ${JSURF_JAVA_GENERATED_SRC} OUTPUT_NAME simgrid) endif() set(JAVA_BUNDLE "${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Scripts/java_bundle.sh") set(JAVA_BUNDLE_SO_FILES ${CMAKE_BINARY_DIR}/lib/${LIBSIMGRID_SO} ${CMAKE_BINARY_DIR}/lib/${LIBSIMGRID_JAVA_SO} ${CMAKE_BINARY_DIR}/lib/${LIBSURF_JAVA_SO} ) set(JAVA_BUNDLE_TXT_FILES ${CMAKE_HOME_DIRECTORY}/COPYING ${CMAKE_HOME_DIRECTORY}/ChangeLog ${CMAKE_HOME_DIRECTORY}/ChangeLog.SimGrid-java ${CMAKE_HOME_DIRECTORY}/LICENSE-LGPL-2.1 ) add_custom_command( COMMENT "Finalize simgrid.jar..." OUTPUT ${SIMGRID_JAR}_finalized DEPENDS simgrid simgrid-java simgrid-java_pre_jar ${SIMGRID_JAR} ${MANIFEST_IN_FILE} ${JAVA_BUNDLE_SO_FILES} ${JAVA_BUNDLE_TXT_FILES} COMMAND ${JAVA_BUNDLE} "${SIMGRID_JAR}" "${Java_JAVA_EXECUTABLE}" "${STRIP_COMMAND}" -so ${JAVA_BUNDLE_SO_FILES} -txt ${JAVA_BUNDLE_TXT_FILES} COMMAND ${CMAKE_COMMAND} -E copy ${MANIFEST_IN_FILE} ${MANIFEST_FILE} COMMAND ${CMAKE_COMMAND} -E echo "Specification-Version: \\\"${SIMGRID_VERSION_MAJOR}.${SIMGRID_VERSION_MINOR}.${SIMGRID_VERSION_PATCH}\\\"" >> ${MANIFEST_FILE} COMMAND ${CMAKE_COMMAND} -E echo "Implementation-Version: \\\"${GIT_VERSION}\\\"" >> ${MANIFEST_FILE} COMMAND ${JAVA_ARCHIVE} -uvmf ${MANIFEST_FILE} ${SIMGRID_JAR} COMMAND ${CMAKE_COMMAND} -E copy ${SIMGRID_JAR} ${SIMGRID_FULL_JAR} COMMAND ${JAVA_ARCHIVE} -uvf ${SIMGRID_FULL_JAR} "NATIVE" COMMAND ${CMAKE_COMMAND} -E remove ${SIMGRID_JAR}_finalized COMMAND ${CMAKE_COMMAND} -E touch ${SIMGRID_JAR}_finalized ) add_custom_target(simgrid-java_jar ALL DEPENDS ${SIMGRID_JAR}_finalized) if(enable_maintainer_mode) set(CMAKE_SWIG_FLAGS "-package" "org.simgrid.surf") set(CMAKE_SWIG_OUTDIR "${CMAKE_HOME_DIRECTORY}/src/bindings/java/org/simgrid/surf") set_source_files_properties(${JSURF_SWIG_SRC} PROPERTIES CPLUSPLUS 1) include_directories(${JNI_INCLUDE_DIRS}) swig_add_module(surf-java java ${JSURF_SWIG_SRC} ${JSURF_JAVA_C_SRC}) add_custom_command(TARGET surf-java POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_BINARY_DIR}/src/bindings/java/surfJAVA_wrap.cxx" "${CMAKE_HOME_DIRECTORY}/src/bindings/java/surfJAVA_wrap.cxx" COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_BINARY_DIR}/src/bindings/java/surfJAVA_wrap.h" "${CMAKE_HOME_DIRECTORY}/src/bindings/java/surfJAVA_wrap.h" ) swig_link_libraries(surf-java simgrid) else() add_library(surf-java SHARED ${JSURF_C_SRC}) target_link_libraries(surf-java simgrid) set_source_files_properties("${CMAKE_HOME_DIRECTORY}/src/bindings/java/surfJAVA_wrap.cxx" PROPERTIES COMPILE_FLAGS "-fPIC -I\"${JAVA_INCLUDE_PATH}\" -I\"${JAVA_INCLUDE_PATH2}\"" ) endif() add_dependencies(simgrid-java surf-java) add_dependencies(simgrid-java_pre_jar surf-java) if(WIN32) set_target_properties(surf-java PROPERTIES LINK_FLAGS "-Wl,--subsystem,windows,--kill-at" PREFIX "") if(PEXPORTS_PATH) add_custom_command(TARGET surf-java POST_BUILD COMMAND ${PEXPORTS_PATH}/pexports.exe ${CMAKE_BINARY_DIR}/lib/surf-java.dll > ${CMAKE_BINARY_DIR}/lib/surf-java.def) endif(PEXPORTS_PATH) endif() SimGrid-3.11/buildtools/Cmake/GenerateDocWin.cmake000644 001750 001750 00000001460 12342443653 021073 0ustar00cici000000 000000 #### Generate the html documentation find_path(WGET_PATH NAMES wget.exe PATHS NO_DEFAULT_PATHS) find_path(NSIS_PATH NAMES makensis.exe PATHS NO_DEFAULT_PATHS) message(STATUS "wget: ${WGET_PATH}") message(STATUS "nsis: ${NSIS_PATH}") if(WGET_PATH) ADD_CUSTOM_TARGET(simgrid_documentation COMMENT "Downloading the SimGrid documentation..." COMMAND ${WGET_PATH}/wget.exe -r -np -nH -nd http://simgrid.gforge.inria.fr/simgrid/${release_version}/doc/ WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY}/doc/html ) endif() if(NSIS_PATH) ADD_CUSTOM_TARGET(nsis COMMENT "Generating the SimGrid installor for Windows..." DEPENDS simgrid simgrid graphicator simgrid-colorizer simgrid_update_xml COMMAND ${NSIS_PATH}/makensis.exe simgrid.nsi WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/ ) endif() SimGrid-3.11/AUTHORS000644 001750 001750 00000001565 12342443666 013115 0ustar00cici000000 000000 SimGrid team is composed of a core team and a bunch of crew members. Simgrid Core Team _________________ SimGrid is a joint project between University of Hawaii at Manoa, LIG Laboratory (INRIA MEScal project, Grenoble, France) and University of Nancy (INRIA Algorille project, Nancy, France). The authors of SimGrid are: Henri Casanova Information and Computer Sciences Department, University of Hawaii at Manoa Arnaud Legrand CNRS, LIG Laboratory (Grenoble, France), INRIA MEScal project Martin Quinson University of Nancy I (Nancy, France), LORIA Laboratory, INRIA Algorille project Fred Suter CNRS, IN2P3 Computing Center Project Crew Members ____________________ Check out our website http://simgrid.gforge.inria.fr/ to see who's doing what in SimGrid! SimGrid-3.11/LICENSE-LGPL-2.1000644 001750 001750 00000063642 12342443666 014110 0ustar00cici000000 000000 GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! SimGrid-3.11/Makefile000644 001750 001750 00000000375 12342443670 013476 0ustar00cici000000 000000 #THIS Makefile should be erase by Cmake when use command "cmake." all : @echo "THIS COMMAND IS NOT AVAILABLE!" @echo "Since v3.4 we use Cmake. Now use:" @echo "\tcmake -DCMAKE_INSTALL_PREFIX= .\n\tmake\n\tmake install" clean : all SimGrid-3.11/ChangeLog000644 001750 001750 00000374232 12342443666 013623 0ustar00cici000000 000000 SimGrid (3.11) stable; urgency=low The Class Release. Tools: * Normalizing pointers addresses tool for better diff between logs Examples: * Add cloud examples using new VMs - examples/msg/cloud/two_tasks_vm.tesh - examples/msg/cloud/simple_vm.tesh - examples/java/cloud/cloud.tesh - examples/java/cloud/migration/migration.tesh * Add java surf examples: - examples/java/surfPlugin/surf_plugin.tesh - examples/java/reservationSurfPlugin/reservation_surf_plugin.tes - examples/java/surfCpuModel/surf_cpu_model.tesh * Add SMPI+MSG example: - examples/smpi/smpi_msg_masterslave/ TeshSuite: * Add tests: - msg process test - msg task destroy cancel test - msg_host on/off test * Move all tests in testsuite to teshsuite (adding tesh files) * Restructure teshsuites - one folder for each kind of test * Restructure AddTests.cmake - unify tests names - structure the order of tests (with sections) MSG: * Add virtual machine - creation of a VM on a PM - migration of a VM from a PM to another PM * New functions - MSG_process_join(msg_process_t process, double timeout) - msg_bar_t MSG_barrier_init(unsigned int count) - int MSG_barrier_wait(msg_bar_t barrier) - void MSG_barrier_destroy(msg_bar_t barrier) - msg_as_t MSG_environment_as_get_by_name(const char * name) * New option "msg/debug_multiple_use" to help debugging when a task is used several times * MSG IO - Improvements and finalization of MSG_storage, MSG_file APIs and their documentation - Increase code coverage in test suites - Bug fixes SIMIX: * Protect context stacks against stack overflow. The number of protected memory pages allocated on the top of each stack (1 by default) can be configured with the new command line option --cfg=contexts/guard_size:. * Simcalls are now generated by a python script that - generates files included by SimGrid - checks that all the functions exist, and proposes prototypes * Clean simcalls - remove sem_destroy, file_set_data, comm_destroy, vm_set_state, host_set_data, host_get_data * New simcalls - simcall_process_join(smx_process_t process, double timeout) * Fix bug where sleeping processing could not be suspended. SURF: * Translate surf models from C to C++ - Generic classes for all models: Model, Resource, Action - A generic interface for each kind of model (CPU, Network, Storage Workstation, WorkstationVM) - C bindings * Translate surf routings from C to C++ * Add callbacks using sigc++ or boost::signals2 - Add callback functions for resource creation/destruction - Add callback functions for action state change - Handle Energy as a plugin * Replace swag by boost::intrusive * Add new routing models for clusters - tori, with topology="TORUS" and topo_parameters="ndim1,ndim2,...,ndimn" parameters for cluster tag - Fat trees, with topology="FAT_TREE" and topo_parameters="h;m1,...,mh;w1,...,wh;p1,...,ph" parameters for cluster tag - see examples/platforms/torus_cluster.xml and examples/platforms/fat_tree_cluster.xml * More documentation SMPI: * Hostfiles support host:nb_processes construct to deploy several processes on one node. * Collective communication algorithms should not crash if used with improper number of nodes and report the error. * SMPI now partially supports MPI_Topologies : MPI_Cart_create, MPI_Cart_shift, MPI_Cart_rank, MPI_Cart_get, MPI_Cart_coords, MPI_Cartdim_get, MPI_Dims_create, MPI_Cart_sub are supported. * New interface to use SMPI programmatically (still depends on MSG for some parts, see examples/smpi/smpi_msg_masterslave) : - SMPI_app_instance_register(const char *name, xbt_main_func_t code, int num_processes) - SMPI_init() - SMPI_finalize(); * Global variables privatization in MPI executables is now performed at runtime with the option smpi/privatize_global_variables (default:no). Limitations : Linux/BSD only, with mmap enabled. Global variables inside dynamic libraries loaded by the application are not privatized (static linking with these libraries is advised in this case) Tracing: * Options defined in XML work correctly now. Java: * New cmake option, enable_lib_in_jar, to control whether native libraries are copied into simgrid.jar or not (ON by default). Use this option if you want to reduce the size of the installed simgrid.jar, *and* the native libraries are kept installed elsewhere. * Surf binding with SWIG (code generated in maintainer mode only): - plugin to handle callbacks - CPU model only for the moment Build System: * Supernovae build mode is definitively removed. It was used to improve inlining and inter-module optimizations. It is nowadays superseded by link-time optimizations commonly available in compilers. * Update ns-3 find lib. Bindings for ns-3 should work again now. * Add boost dependency for surf++ * Add new macro for tests - ADD_TESH(name ) - ADD_TESH_FACTORIES(name "thread;ucontext;raw" ) XBT: * New functions - xbt_bar_t XBT_barrier_init(unsigned int count) - int XBT_barrier_wait(xbt_bar_t barrier) - void XBT_barrier_destroy(xbt_bar_t barrier) * Make the xbt_os_time module public -- Sat May 31 22:39:38 CEST 2014 Da SimGrid team SimGrid (3.10) stable; urgency=low The Clean Diaper Release, a.k.a. SimGrid is leak-free. Java: * Reintegrate Java to the main archive as desynchronizing these package is not acceptable anymore (Java is now considered stable) * Add explicit synchronization facilities through semaphores * Bug fix: Task.setDataSize() only changed the C world, not the value cached in the Java world MSG: * Dramatically change the way files are handled. API and internals changed, but this part of MSG was not considered as production grade either. * Add explicit synchronization facilities through semaphores * Add a new function MSG_host_get_process_list() * Preliminary DVFS support (see examples/msg/energy/ for details) SMPI: * SMPI is now included directly in the libsimgrid as the windows linker doesn't force us on splitting it anymore. * Improvements of the SMPI replay tool: - Most of the collective communications are now rooted in the same process as in the original application. - Traces now rely on the same MPI data type as the application (MPI_BYTE was used until now). Multiple data types can now be used in a trace. - The replay tool now supports traces produce either by TAU or a modified version of MPE. - Bug Fix: the compute part of the reduce action is now taken into account. - Gatherv collective is now supported - SimGrid (SMPI for now) can generate replay traces as well. Option -trace-ti of smpirun outputs time independent traces for the current run. One file is created per process. If too many processes are simulated, this behavior can be changed to one file for all processes by using the tracing/smpi/format/ti_one_file flag * smpirun generates the host file if needed (with given host count and platform) * Integration of more than 100 STAR-MPI, MPICH, OpenMPI collective algorithms - allows to select one in particular with --cfg=smpi/coll_name:algorithm - allows to use the decision logic of OpenMPI(1.7) or MPICH(3.0.4) by setting --cfg=smpi/coll_selector:(mpich/ompi) * Support for new functions : MPI_Issend, MPI_Ssend, Commutative operations in Reduce * Add a --cfg:tracing/smpi/internals option, to trace internal communications happening inside a collective SMPI call. * Fix the behavior of complex data types handling. * Make MPI_Wtime another synchronization point to take computations into account. * Replace MPICH-1 test suite by the one from MPICH 3.0.4. Can be built using enable_smpi_MPICH3_testsuite flag in cmake. Run with ctest. * Add all missing Fortran bindings, SMPI should work with Fortran 90 (no privatization of global variables yet) * Preliminary DVFS support (see examples/smpi/energy/ for details) Model-Checking; * Verification of liveness properties is now available for SMPI applications (in addition to MSG applications) * Bugged examples using SMPI in examples/smpi/mc/ * Add --cfg=model-check/visited option. Allows the verification of infinite programs. Detection of loops in the execution thanks to the system state comparison and reduction of the state space to explore. Can be combined with DPOR for safety properties. SimDag: * Allow to change SimGrid configuration (see --help) within the code thanks to SD_config() as it can be done in MSG. * Add a new function SD_task_set_amount() upon user request. PLATFORM: * Handle units for values (10ms, 10kiloflops, 10Bps, 1GB, ...) * Remove rule based routing (no more PCRE dependency) * Add a limiter_link option to cluster tag, to specify a maximum reachable bandwidth in fullduplex mode when it is less than twice the nominal bandwidth. * Add a loopback_bw and loopback_lat options to cluster tag. * Fix the peer tag that could not be mixed with other AS within a Vivaldi routing. Now peers are encapsulated in an AS and have their own private router but this is transparent. XBT: * Our own implementation of getline is renamed xbt_getline, and gets used even if the OS provide a getline(). This should reduce the configuration complexity by using the same code on all platforms. * New type: xbt_cfg_elm_boolean. * Allow to use yes/no for boolean configuration options in the command line. * Allow to disable SimGrid cleanups at exit from command line option. There are situations where one may want a simulation to end with an exit. Unfortunately, calling exit may cause SimGrid to segfault, which is quite annoying when scripting around the simulator. Adding a --cfg=clean_atexit:no allows to circumvent this issue. Build System: * Lots of memory leaks were corrected in this release. There is no known memory leaks anymore, in all of our 600+ tests. * New command line option --version, to get SimGrid version information. Packagers may want to add extra words to SIMGRID_VERSION_EXTRA defined in CMakeLists.txt. * Supernovae builds are deprecated, and expected to be removed in the next version of SimGrid. -- Sun Nov 17 00:26:44 CET 2013 Da SimGrid team SimGrid (3.9) stable; urgency=low The Grasgory release: GRAS is really dead now. * Complete overhaul of the internal host structures scheme. GRAS: * If you use GRAS, you should stay at SimGrid 3.5 (at most) since it was considered as experimental and badly maintained since then. * Keeping it was thus a trap to our potential users, that could take it instead of MSG or SMPI by mistake despite is pity state. * GRAS seems to have very few users (if any), and no one volunteered to maintain it further. It also induces a lot of XBT code (for portability sake), that must be maintained too. * For all these reasons, we killed GRAS. If someone wants to revive it in the future, don't cry, our git history still remembers of GRAS. Documentation: * Major overhaul. Merge our documentation again as time proved that splitting it was really not helping our users. * Further improve the developer documentation to help newcomers hacking on SimGrid itself. The user documentation (and in particular, the beginner documentation) is still in a sorry state. SMPI: * Now works on Windows too! * Much more extensive test suite, from MPICH SIMDAG: * Add a new loader (SD_PTG_dotload) that creates a parallel task graph (i.e., a DAG whose nodes are parallel tasks) from a dot file. Creates a dynar of SD_TASK_COMP_PAR_AMDAHL and SD_TASK_COMM_MXN_1D_BLOCK tasks. * Bug fix: let task be scheduled when the last dependency to be solved is a control dependency. * Remove SD_load_environment_script function. Use the C sg_platf function if you want to declare a platform programmatically. MSG: * New function: MSG_process_get_number() * Old function documented: MSG_config() * Remove MSG_load_platform_script function Use the C sg_platf function if you want to declare a platform programmatically. SURF: * Change the default value of the TCP_gamma constant (maximal size of TCP congestion window) to a more realistic 4MiB value. If you notice changes in your simulation results, you can fall back to the previous 20k tiny window by adding --cfg=network/TCP_gamma:20000 on command line. * (Hopefully) fix a bug wrt periodic availability and state traces * Bug fix: use default values at start when first event in availability/state trace is not at time 0. PLATFORM: * remove the "new_" part of function name sg_platf_new_trace_connect (resulting in sg_platf_trace_connect), since it does not create anything new XBT: * Kill synchronized dynars, and xbt_dynar_dopar(). We cannot think of a use case where it's really mandatory, and maintaining it was a pain in our code base. * New: xbt_fifo_search(), search an item with a user-provided comparison function instead of dumb pointer comparison. LUA: * Fix the lua deployment: Use `simgrid.init_application()` before deployment instead of `simgrid.msg_register_application()` after. TRACING: * Transfer the tracing files into the corresponding modules. -- Tue Feb 5 11:31:43 CET 2013 Da SimGrid team SimGrid (3.8.1) stable; urgency=low The "we are told that some people want to also *install* the simgrid framework" release. * Add missing file "tesh.1" to the archive. -- Sat Oct 27 16:12:11 CEST 2012 Da SimGrid team SimGrid (3.8) stable; urgency=low The Psssshiiiit release: SimGrid jumps into the Cloud. MSG: * Add an experimental interface to manipulate VMs. They are mainly process groups with very few intrinsic semantic, but they should allow you to build the semantic you want easily. * New function: MSG_host_set_property_value() * New function: MSG_process_on_exit(). To clean memory in all cases. * Bug fixes that made the host (and link) failures unusable. * Add a way to auto-restart process when the host in which they are executing comes back (ON_FAILURE="RESTART" on deployment file, MSG_process_auto_restart_set). * Use the "msg_" prefix for all datatypes (instead of m_, msg_ and MSG_), please stop using the old ones, they are DEPRECATED. * Deprecate functions MSG_global_init() / MSG_global_init_args() Please use MSG_init() instead. (reducing the amount of entry points in the library helps us). * Make it impossible to link against the wrong version of the lib * Deprecate MSG_clean(). No need to call it anymore. * Function MSG_get_host_number() is not deprecated anymore. Documentation: * Split the doc into a user guide and a reference guide. * Start a developper guide to help people hacking on SimGrid. Cmake: * Enable tracing by default. This modules rocks you should use it. * Remove option custom_flags. Now use environment variables CFLAGS and LDFLAGS. * Use default cmake things to detect lua instead of home grown ones. * New option "enable_mallocators" to disable mallocators, for debugging purpose ("on" by default). SIMIX: * Bug fixes around the resource failures: don't let the processes survive the host they are running onto. * Add an interface to auto-restart processes when the host in which they are executing comes back. * Ensures that SIMIX_clean is called automatically. It's not part of the public interface anymore (bindings should be updated). SimDag: * Bug fix for when SD_Simulate is called with a positive value: be careful when comparing doubles. Sometimes they are different for non significant digits only. * New types of typed tasks. SD_TASK_COMP_PAR_AMDAHL represents a parallel task whose initial work is distributed among host according to the Amdahl's law. Such tasks are created with a parameter alpha that corresponds to the non-parallelizable part of the computation. SD_TASK_COMM_PAR_MXN_1D_BLOCK represents a complex data redistribution between two sets of workstations assuming a 1D block distribution (each workstation owns a similar share of data) on both sides. These tasks can be scheduled with SD_task_schedulel or SD_task_schedulev. Data redistribution will be automatically scheduled once parent and child are both scheduled. The filling of computation_amount and communication_amount structures is now done seamlessly thanks to the chosen assumptions. * New function SD_workstation_dump to display various information * New function SD_task_set_rate to throttle the bandwidth allowed to be used by a SD_TASK_COMM_E2E typed task. This rate depends on both the nominal bandwidth on the route onto which the task is scheduled and the amount of data to transfer. To divide the nominal bandwidth by 2, the rate then has to be : rate = bandwidth/(2*amount) * Compute tasks that have failed can now be rescheduled and executed again (from their beginning) * Increasing source code coverage (src/simdag is now covered at 95.8% on average) SMPI: * Re-implement time-independent trace replay using SMPI (at the smpi_smp_* level) instead of MSG. This should replace examples/msg/actions/actions.c * Implement support of MPI Datatypes (vectors, hvectors, indexed, hindexed and structs) * Implement the exchange of non-contiguous data. [Khalid Hasanov & Jean-Noel Quintin] Thanks for the patch, guys. * Correct behavior of smpi/sender_gap and set its default value to 0 * Add option to asynchronously send small messages to allow better simulation of pt2pt communications. --cfg=smpi/async_small_threshold:value specifies the size in bytes under which messages will be asynchronously sent. * Add support of MPI_Iprobe, MPI_Probe, MPI_Testall, MPI_Wtick functions * SMPI now handles more MPI specific values in input. Closes [#14389] and [#14388] SimGrid: * New C interface to define a platform: XML is now optional. For more info, please check include/simgrid/platf.h. * New interface to define random platforms from the C: For more info, please check include/simgrid/platf_generator.h and examples/msg/masterslave/masterslave_platfgen.c * Export a sg_cmdline dynar containing all the arguments we got from the command line. TRACE: * Two new tracing options for adding comments to trace file so you can track your experiments (see --help-tracing for details). * New option to generate a impoverished trace file (--cfg=tracing/basic:1) * Adding the SimGrid version that generated the trace file as a comment. * Instrumenting other MSG functions (MSG_task_isend_with_matching and MSG_task_dsend) * Fix to avoid key clashes on Paje links * Other minor fixes related to the Paje specification XBT: * Functions xbt_dict_hash() and xbt_dict_hash_ext() are made public, and renamed to xbt_str_hash() and xbt_str_hash_ext(). * New function: xbt_os_timer_resume() to restart a timer w/o resetting it. * Greatly improve the robustness of mmalloc to user errors (such as using an area after freeing it, or freeing it twice) -- Thu Oct 25 17:30:06 CEST 2012 Da SimGrid team SimGrid (3.7.1) stable; urgency=low MSG: * Restore the prototype of MSG_process_create_with_environment() to the pre-3.7 situation by removing the kill_time argument. * Add a MSG_process_set_kill_time() function instead. SURF: * Fix weird behaviors when dealing with parallel tasks. WINDOWS: * Simgrid is now built as a dll. * Simgrid-java now works on Windows. * Simgrid-Java is now included into Windows package. MacOS: * First pre-build package for MacOSX. Build System: * Fix compilation when using MSG_USE_DEPRECATED. * Fix some compilation issues on Macs and Windows. * Reduce the number of failing tests on exotic systems, like Debian/Hurd. * Environment variables CFLAGS and LDFLAGS are now honored by cmake. We discovered that the Lua console is broken, but we are missing the manpower to fix it right now. The problem existed in 3.7 too, so we are not blocking the release for that. Sorry if you depended on this feature, any help would be really welcome. -- Thu Jun 7 2012 Da SimGrid team SimGrid (3.7) stable; urgency=low The "spring cleanups (before the next Big Project kicks in)" release. Models: * We can specify the SMPI latency/bandwidth factor with command line add --cfg=smpi/bw_factor:"threshold0:value0;...;thresholdN:valueN" or add --cfg=smpi/lat_factor:"threshold0:value0;...;thresholdN:valueN" You can also use the "config tag" from platform file by adding this line (see "example/platforms/tag_config.xml" to use "config tag"). Note that the command line supersedes the platform file configuration. * Change the correction factors used in LMM model, according to the latest experiments described in INRIA RR-7821. Accuracy should be improved this way. * Use the partial invalidation optimization by default for the network too. Should produce the exact same results, only faster. * Major cleanup in surf to merge models and split some optimization mechanisms from the core of the models. As a result you can now specify which model to use (e.g., --cfg=network/model:LV08 --cfg=cpu/model:Cas01) and which optimization mode to use (e.g., --cfg=network/optim:lazy --cfg=cpu/optim:TI). Incompatible combinations should err at initialization. See --help-models for the list of all models and optimization modes. * The CLM03 workstation model was dropped for simplicity because it used the deprecated CM02 network model. Use default instead. * Rename the TCP_gamma configuration option to network/TCP_gamma * Rename the coordinates configuration option to network/coordinates, and document it * Use now crosstraffic keyword instead of the terribly misleading fullduplex keyword. It is activated by default now in the current default model, use --cfg=network/crosstraffic:0 to turn it off. * Ongoing refactoring the model parsing to make XML files optional See include/simgrid/platf.h for details (still to be completed) MSG: * Major overhaul of the documentation. Almost instructive now :/ * Deprecate the use of m_channel_t mechanism like MSG_task_{get,put} functions and friends. This interface was considered as deprecated since over 2 years, it's time to inform our users that it is. Switch to MSG_task_{send,recv} instead, or compile SimGrid command line 'cmake -Dcustom_flags="-DMSG_USE_DEPRECATED" .' if you really need to use these (crappy) functions in your code. These functions will be removed soon. Stop using them now. * Deprecate MSG_get_host_{table,number} Implement MSG_hosts_as_dynar() instead. * Implement MSG_processes_as_dynar() (Closes gforge #13642) * Remove the public field msg_host_t->name. Use MSG_host_get_name() Simix: * Stabilize the parallel execution mode of user contexts * Introduce configuration variables to control parallel execution: - contexts/synchro: Synchronization mode to use when running contexts in parallel (either futex, posix or busy_wait) - contexts/parallel_threshold: Minimal number of user contexts that must be part of a scheduling round to switch to parallel execution mode (raw contexts only) * Fix bugs that prevented to use suspend/resume along with synchronization structures. * Fix bugs in process termination that lead to invalid memory access in very specific conditions. SURF: * Introduce a parallel mode for the models (controlled by surf/nthreads configuration item). In our tests, running the models in parallel never lead to any speedups because they are so fast that the gain of computing each model in parallel does not amortizes the synchronization costs, even when ultra fast futexes are used. This is released anyway because YMMV. SimDag: * Performance boost by using a swag internally to compute the set of tasks that are finished and should constitute the return value of SD_simulate. SMPI: * Enable it by default now that it is considered rather stable. TRACE: * Documentation of the tracing functions. * Performance gains when tracing categorized/uncategorized resource utilization by avoiding calls to get route when updating resource variables. LMM constraints are being used instead. * API changed to set task categories. Use MSG_task_set_category instead of TRACE_msg_set_task_category, and SD_task_set_category instead of TRACE_sd_set_task_category. They only work if ENABLE_TRACING is ON. * Bugfix for graphicator, routes not correctly obtained, memory leaks * Examples for link user variables added (see at examples/msg/tracing/) * Deprecated function TRACE_msg_set_process_category completely removed * Trace header updated according to the latest Paje file format * Tracing network lazy updates, no longer obligate users to use full updates * --cfg=tracing/platform:1 also registers power/bandwidth variables * Experimental: let user code declare/set/push/pop application states for hosts * API changed to allow the manual creation of graph configuration files for Triva. See TRACE_get_node_types() and TRACE_get_edge_types(). Lua: * Improve the API of Lua MSG bindings, using the Lua spirit. * Each simulated process now lives in its own Lua world (globals are automatically duplicated). It helps writing simulators. Will allow to run Splay programs within SimGrid in the future. * Add a Chord example in Lua, equivalent to the MSG one. MODEL-CHECKING: * Start the implementation of a solution to express temporal properties, not only local assertions. This is still an experimental work in progress, stay clear from it to be safe. XBT: * Logs: - Add new runtime parameters --help-logs and --help-log-categories to display informations about supported logging parameters and categories. - Old deprecated parameters --{gras,surf,msg,simix,xbt}-log=... don't exists anymore. * Mallocators: allow value NULL for the reset function. * Dicts: - New function xbt_dict_new_homogeneous(void(*)(void*)) to create homogeneous dictionaries, where all the elements share the same free function. Non homogeneous dictionaries will be deprecated in the next release. - Dicts of scalar elements (xbt_dicti_*) are deprecated. - Multi-level dictionaries are deprecated. * Dynars: - new function xbt_dynar_search_or_negative() that is useful when you have less than 2 million elements in your dynar and don't want of the extra complexity of catching exceptions when the element is not found. * Portability layer - Make xbt_os_thread module (for thread portability) public. Documentation is still to come, sorry. * mmalloc module: - Cleanups and simplifications to make it maintainable again. - Exotic features (such as memalign and valloc) were removed. - The metadata were extended and improved so that the model-checker becomes able to explore and inspect the heaps. - This may induce a performance drop when enable_model-checking is ON in cmake (even if it's not used in the simulation), but it is necessary at this point to get MC working. Turn model-checking OFF if simulation performance matters to you. Not enabling it at runtime is not enough, disable it in cmake. -- Tue May 15 11:30:19 UTC 2012 Da SimGrid team SimGrid (3.6.2) stable; urgency=low The "Not coding new stuff allows to polish old things" release. General * New bindings to the NS3 packet level simulator (experimental) * Use the raw (efficient) execution contexts instead of the sysv (portable) ones when possible. * libpcre is now mandatory in any cases since not using it led to severe performance loss and possibly other issues * Update the XML platforms: - G5K: include the latest machine in Nancy - GridPP and LCG: new platforms * Documentation was partially updated, at least (more to come) Bug fixes, cosmetics and small improvements * Free terminated processes before the end of the simulation to avoid exhausting the memory of users having very dynamic amount of processes. * Bug fix and cosmetics about canceling non-running tasks * Bug fix about the dot loader's issues when using libcgraph Portability * Create an installer for windows with nsis (amd64 and win32) - Add an hello world project to illustrate simgrid project creation. - Embed libpcre into the Simgrid installer to avoid its compilation burden * The raw execution contexts should work on Apple now * Port to Windows 64 bits - Sysv contexts now have an implementation for this arch - GRAS communication features now support this arch * Drop support for borland compiler on windows - this code was not maintained, and we kinda depend on gcc nowadays * Fix portability issues on kfreebsd/gnu: build error about semaphores * Fix portability issue on unstable ubuntu: linker became picky on argument order -- Wed Oct 5 15:51:01 CEST 2011 Da SimGrid team SimGrid (3.6.1) stable; urgency=low The "Oops, we broke Macs too" release Portability * Fixed contexts detection so that raw ones are used when possible * On Mac, do not use Posix Ucontexts with gcc v4.[1-5] since this leads to a strange error, with user code segfaulting sometimes when the generated code is not perfectly aligned (which is not controllable from the user side, depends on the amount of code) XBT * New macro: CATCH_ANONYMOUS, which is like CATCH(e) but without argument. -- Mon Jun 27 13:59:03 CEST 2011 Da SimGrid team SimGrid (3.6) stable; urgency=medium The Summer Release, also known as the "OMG! They Killed Kenny!" version Java and Ruby: * Bindings now constitute their own package, separated from the main one. Rationale: reduce our maintenance nightmare by reducing the module coupling They will soon be released on their own on gforge. * In the meanwhile: svn co svn://scm.gforge.inria.fr/svn/simgrid/contrib/trunk/simgrid-java svn co svn://scm.gforge.inria.fr/svn/simgrid/contrib/trunk/simgrid-ruby GRAS: It is not considered as stable anymore, but experimental. Sorry. * It's not quite deprecated for now because we have no replacement, but it may soon become the case. SMPI * New MPI functions supported: MPI_Comm_disconnect, MPI_Comm_get_name * Fortran: New user-level cache variable to store the rank of the running process. This improves performance by an order of magnitude. * C: New coccinelle script to automatically locate and modify global and local static variables. * Improved SMPI network model with a sender-side gap to account for multiple parallel sends. MSG * New function MSG_comm_get_status(). MSG_comm_test() and MSG_comm_testany() only say if a communication is finished, no matter whether it succeeded or failed. You can call MSG_comm_get_status() to know the status of a finished communication. * New function MSG_task_dsend() to send a task and detach it. When a communication is detached, you are never notified of its success or failure and the memory is released automatically once it is finished. This function is useful when you don't care about the end nor the success of a communication. * Change the prototypes of action replay. Sorry for inconvenience, but this is really more efficient this way (and to adapt your code, you just have to fix the initialization, that shouldn't be too long) * Kill the braindead MSG_task_refcount_dec() function. I guess nobody ever managed to do anything useful with it. * New function MSG_comm_testany(). Similarly to MSG_comm_waitany(), it takes a dynar of communications. It returns immediately and gives the index of a finished communication (if any). * New example: a basic implementation of the Chord P2P algorithm. SURF * New model for multi-core CPUs. You can now use the core attribute to precise the number of cores of a host. This is a basic model. Every process running on the host receives at most the power provided in the DTD (throughput<=power). Total throughput of process cannot exceed power * num_cores. * New peer tag. This peer tag creates a tiny AS comprising a host and a router linked by an up-link and a down-link (possibly asymmetrical). This kind of pattern allows to easily build last-mile model style platforms. Aggregating such patterns in a rule-based AS is thus the technique of choice for modeling large peer-to-peer/volunteer computing/cloud platforms. * New model for Vivaldi routing. We transformed the Vivaldi network model into a Vivaldi routing model (based on the rule-based model). This allows to combine Vivaldi based latencies with last-mile platforms. SIMIX * Added a check for NaN of IEEE754 infinite in the double entries of the smx_user.c file * Introduce a new context factory "raw", highly inspirated from the ucontext factory, but using manually crafted functions in assembly to do the work in an efficient manner. * Allow to change the used context factory at run time, not only at compilation time. Use --cfg=contexts/factory:raw for maximal speed. * Add an option --cfg=contexts/stacksize:N to set the stack size of the user contexts at runtime (only with raw contexts or ucontexts). * Completely rewrote this module to allow parallel execution of user processes. Use --cfg=contexts/nthreads:N to execute user processes with N parallel threads (the default is 1, meaning no parallelism). * Allow to decide dynamically between sequential and parallel modes. When nthreads > 1, you can use --cfg=contexts/threshold:P to run the user processes in parallel only when their number is greater than or equal to P (the default is 2). * Added a check for NaN of IEEE754 infinite in the double entries of the smx_user.c file XBT * New command line option: if you pass --cfg=verbose-exit:0, SimGrid won't output the state of processes when interrupted with Ctrl-C * Add a new function xbt_dynar_to_array that transforms a dynar into a NULL-terminated array. This may solve backward compatibility issues due to the change to return type of SD_simulate. See also: http://lists.gforge.inria.fr/pipermail/simgrid-user/2010-December/002206.html * Add new macros with variable number of arguments. - in xbt/log.h: XBT_DEBUG, XBT_VERB, XBT_INFO, etc. - in xbt/asserts.h: xbt_assert - in xbt/cunit.h: xbt_test_{add,fail,assert,log} - in xbt/ex.h: THROWF and RETHROWF. Define XBT_USE_DEPRECATED if you want to use the old numbered macros like INFO1, INFO2, etc. * Change xbt_die() to accept a format string with arguments, just like printf. * New data structure: xbt_lib_t, like a dict but more general and with better memory handling. INSTR * New configuration options Options triva/categorized and triva/uncategorized can be used to generate graph configuration files for Triva visualization tool. * Configuration option tracing/platform is renamed to tracing/categorized * XBT logging makes tracing error checks easier, new root log hierarchy: instr * New TRACE_user_link_variable interface: User provides the name of the link and the tracing variable to attach to it * the declaration of tracing categories must be done after the environment creation * simpler tracing interface, just one way to declare categories TRACE_category or TRACE_category_with_color, it is up to you * links in the trace file are again identified by their names * trace contains the full platform hierarchy exactly as declared using the ASes * Options tracing/msg/[task|process]:1 groups the process by hosts for both cases, tasks and processes must have names that are unique during the simulation these options generate traces that are suited to gantt-charts, such as the space-time view of Paje * The experimental option tracing/msg/volume is deprecated its functionality may be reincorporated if needed * Buffering The tracing generates a trace file with unordered timestamped events, because of the way the core simulator (surf) works. A script available at the tools directory (fix-paje-trace.sh) can be used to put the events in order. We have changed the tracing so it can generate ordered timestamped events in the final trace, but depending on the simulator (and how much time is simulated) that can lead to a huge memory utilization. It is deactivated by default, but it can be activated using the --cfg=tracing/buffer:1 switch. Build Infrastructure * Define a SIMGRID_VERSION macro in simgrid_config.h. - We are trying hard to keep the API stable, but it may happen that some things change (we're a research project after all, not a nuclear plant operating system). If such things should happen, you could rely on that macro to adapt. - current value: 30600 for 3.06.00, aka 3.6 * Define macro MAKE_SIMGRID_VERSION(major, minor, patch) to help building a number that can be compared with SIMGRID_VERSION. * Add a build option -Denable_debug (set to ON by default): when set to OFF, assertions and verbose/debug logging events are disabled at compile time. -- Tue Jun 21 08:57:43 CEST 2011 Da SimGrid team SimGrid (3.5) stable; urgency=medium Model Checking * New feature to any SimGrid-based simulator: Model-Checking Check SIN#1 for more details. SMPI * New Model SMPI (three-interval linear regression for correction factors) See RR-7426, available at http://hal.inria.fr/inria-00527150 * Ability to use FORTRAN MPI code (through f2c, automatically privatized) * New MPI functions supported: MPI_Get_count(), MPI_Comm_split() * New: RAM folding (see RR-7426 and examples/smpi/NAS/DT-folding) * New: execution sampling (see RR-7426 and examples/smpi/NAS/EP-sampling) * See also src/smpi/README Tracing: Tracing: * Tracing system - Tracing API changes: TRACE_start and TRACE_end should not be called by user-code. They are automatically called by simulators created with SimDAG, MSG and SMPI if the toolkit is compiled with tracing_enabled=ON. Categories declaration and utilization remain the same for MSG and SimDag. - A function was added to the tracing API to declare categories with colors: - TRACE_category_with_color (char *category, char *color) where color must be in the following format "%f %f %f", red, green, blue and red, green, blue are float values in the interval [0, 1] - User can specify NULL as color parameter, or continue calling TRACE_category (cat) On that case, the tracing system will define random colors - The following command-line options are supported: --cfg=tracing/filename:msg.trace --cfg=tracing:1 (activate tracing, needed to use others) --cfg=tracing/platform:1 (categorized resource use) --cfg=tracing/uncategorized:1 (uncategorized resource use) --cfg=tracing/msg/task:1 (task creation) --cfg=tracing/msg/process:1 (process creation, migration) --cfg=tracing/msg/volume:1 (volume of MSG send/recv) --cfg=tracing/smpi:1 (SMPI interface tracing) --cfg=tracing/simdag:1 (allow SimDAG tasks receive categories) - examples of examples/msg/tracing updated * Tracing SimDag - DAXLoader and DOTLoader functions can generate tasks with categories - A new function to attribute a category to SD tasks: TRACE_sd_set_task_category (SD_task_t task, char *category) * Tracing the MPI interface implemented by SMPI - Collective operations are traced with states - Point-to-Point operations are traced with states/links - Tracing activated by a parameter "-trace filename" passed to smpirun during execution (considering that simgrid is compiled with tracing enabled) - To run the simulation with gdb, the simulator accepts --cfg=tracing/smpi:1 to trace SMPI - tesh files to check if smpi tracing is ok - See examples/smpi/NAS/DT-trace * GTNetS tracing re-worked - adaptation to the tracing system of GTNets to cope with modifications regarding the fullduplex mode - new tesh files to check if gtnets tracing is ok MSG * Asynchronous communications through the functions: MSG_task_isend/irecv and MSG_comm_test/wait/waitall * New function: MSG_load_platform_script() to make possible using a lua script instead of XML files to set up platforms * New function: MSG_set_function to associate functions to processes, used when bypassing the parser * New functions: MSG_task_set_name(), MSG_task_set_compute_duration() Platforms: Add some more examples in examples/platforms * Grid'5000: see www.grid5000.fr * *_30000_hosts.xml: various huge files [mainly scalability testing] SURF * Change the XML format. This is a very important modification. SimGrid 3.5 introduces a new hierarchical format based on the notion of Autonomous Systems. Compatibility with old format is ensured through the perl script provided in the install bin directory bin/simgrid_update_xml. It is now possible to build platforms with specific routing mechanism (Full/Dijkstra/DijkstraCache/Floyd) and to easily connect several platforms together. We will try to provide soon set of realistic platforms exploiting these properties (have a look at examples/platforms/ for the moment). * Take the opportunity of the XML format change to be a good XML citizen: rename link:ctn to link_ctn and similar changes (also dealt with by simgrid_update_xml) * Add a new routing scheme (rule-based) using regular expressions. It enables to have an extremely low memory footprint when the underlying routing is simple and can be compactly described. You need to have libpcre4-dev (perl regular expressions) installed if you want to use this routing scheme. * Revive the cluster TAG and allow to easily and efficiently (both in term of memory and speed) connect clusters together. Have a look at teshsuite/simdag/platforms/ to see how this can be done. With this tag, you can create clusters with thousands of tasks at no cost (have a look at examples/platforms/). Note: clusters are implemented as ASes, so there is no need for an enclosing AS tag if you have only one cluster in your platform. * Add new generic functions in the public interface that allows the user to call SURF 'create_resource' methods from your code (same functionality as the XML bypass mechanism but with a much lighter burden). * Add a new model (enabled through command line --cfg=network/model:SMPI) that uses a piecewise linear approximation to produce better results when exchanging small messages. * Add a new parameter to handle correctly full duplex link and account for interferences between uplink and downlink communications (activate with --cfg=fullduplex:1). SIMDAG * Rename the SD_READY (all dependencies are satisfied and task is scheduled) state in SD_RUNNABLE and define a new SD_SCHEDULABLE (all dependencies are satisfied) state. This prevents a confusion between the notion of "ready to schedule" (SD_SCHEDULABLE) used in DAG scheduling and that of "ready to be simulated" (SD_RUNNABLE) used by the simulation kernel. * Change the way a task is considered as ready. Instead of removing dependencies when a task is done, a counter is decreased. This way, it is always possible to reach ancestors thanks to the SD_taks_get_parents function (even after the end of the simulation.) * Change the return type of SD_Simulate from (SD_task_t*) into xbt_dynar_t. This function was in handling a dynar internally and converted it into a NULL terminated array for historical reasons. * New function SD_dotload(char*) to load a DAG described in dot format. This loader and the corresponding examples require the installation of the graphviz library. * Fix a bug in the management of tasks of size 0 in the surf network models. This problem was only visible with SIMDAG and you should thus disregard results produced with earlier versions if you relied on this feature (some tasks were blocked because of this). * Fix a bunch of stuff that prevented to use classical models with SIMDAG even though your applications were doing only point-to-point communications and sequential computations. Now you can really use any model you want (of course, if you create real parallel tasks, which are not implemented in most models beside ptaskL07, this will abort). * Add an example that schedules a DAX on an heterogeneous platform using a Min-Min strategy. * New function SD_workstation_get_current_task() that returns the kind of task currently running on a workstation in the sequential access mode. * Raise some warnings when unexecuted tasks remains at the end of the simulation. This is usually caused by cycles in the DAG. SIMIX * New function: SIMIX_process_set_function() called by MSG_set_function * Change the underlying waiting queue in semaphores so that a process can wait on several of them simultaneously (as in waitany). * Fix the way to handle tokens in semaphores so that all access patterns work: {acquire, acquire_timeout, waitany} / {release, release_forever}. * kill the dirty pimple SIMIX_message_sizes_output() Please use (proper) visualization instead XBT * New data container: setset (set of sets of elements) * New module: mmalloc (mapped malloc, allowing to have several independent segments of malloc) * New function: xbt_dict_cursor_set_data() * New functions: xbt_dynar_sort(), xbt_dynar_compare() * New function: xbt_dynar_is_empty() * New function: xbt_fifo_get_last_item() * Fix xbt_dynar_shrink(): use the right element size. * Fix xbt_dynar_set*(): allow index larger than current size and memset 0 uninitialized areas during expand. * Fix semaphores: previous implementation was severely broken. * Use library init/fini functions for our initialization. - you can use logs and other feature as soon as you want in your code (even before the xbt_init / MSG_init) - xbt_exit is now a no-op and produce a warning when used. GRAS: * Port GRAS to new SIMIX mechanisms. This allows gras users to benefit from the latest improvement to the simulation kernel. * Kill measurement sockets for now. If you rely on them, sorry. This release is not for you. This feature will be reintroduced in the future, but we cannot delay the release any further. * New function: gras_msgtype_get_name(). * Implement gras_agent_spawn in RL too (the prototype changed a bit) * Fix (at last) the pmm example: it should not randomly fail anymore. Build chain: bug fixes and overall polishing * Cmake is now stable enough. Hence, we killed the autotools. * Port to windows ( TM :) * Fix the 'make install' target. No need to use 'make install-simgrid' anymore * Introduce a 'make dist' target compiling a *source* archive 'make package' compiles a binary archive * Compile java files only on need * Add --cd and --setenv command line options to tesh * Out of source builds are not fully supported yet, but we are close * Enable supernovae and optimization flags by default for our users LUA Bindings * Add layer to set up environment directly from lua, without XML. * The effect of gras_stub_generator can be achieved through lua too (check examples/gras/console/ping_generator.lua) -- Wed, 01 Dec 2010 22:09:23 +0100 Da SimGrid team SimGrid (3.4.1) stable; urgency=low The "Polishing easter eggs is probably a good idea" release. This is a bug fixes release only. Java Bindings * Fix a bug preventing the tasks from begin garbage collected. MSG * Fix a bug occuring when a host involved in a communication fails. This was not detected properly by the other peer involved in the communication. Now, it's reported as a network error. SimDag * Warn the user about loop dependencies in data flow of DAX files * Obey the control-flow dependencies of DAX files Cmake * Add option "enable_smpi" allowing to not compile SMPI. Probably useful for the (Mac) users experiencing a build error here * Improve the detection of lua5.1 and ruby1.8 -- Da SimGrid team Tus, 04 May 2010 28 16:11:16 +0100 SimGrid (3.4) stable; urgency=low The "Easter in Cargese" release. Also known as (major changes): * the "se habla Java, Ruby 話せます, fala-se Lua (and deaf-friendly)" ~> bindings were greatly improved ~> new tracing infrastructure for better visualization introduced * the "Welcome to configury modernity" release. ~> we switched from autotools to cmake, and improved our cdash A more detailled list of changes follow (full detail in svn log). Java Bindings: Various Cleanups * (install java-gcj-compat-dev on debian-like to use them) * Remove put/get: no need to export deprecated interface in Java Use send/receive instead. * Cleanup the examples and add a README per directory * Remove example autoDestination (that's the only way to go now) * Remove example explicitDestination (was a plain copy of basic) * Make JniException a runtime exception, so that there is no need to declare the fact that you may encounter such a beast. I guess that nobody will ever want to survive such error. * Create specific errors for each MSG case of failure: host failure, transfer failure, timeout, task cancelled * Cleanup the exceptions that may get thrown by each function * Other internal cleanups in Java bindings. Performance still bad :/ Ruby and Lua Bindings: create them * (install ruby1.8-dev/liblua5.1-0-dev on debian-like to use them) * That's new and great, you should try them out. Same functionalities than Java bindings, only even less polished SimDag: * Kill the useless "rate" argument of SD_task_get_execution_time() Everyone used to provide -1 as a value, it was not used, and the semantic of a possible use wasn't even clear. * SD_SCHED_NO_COST: Constant to use as cost in SD_task_schedule() either as comm costs or compute costs to mean that there is no such thing for that specific task. * Add a SD_task_set_name() function * Fix SD_task_unschedule() on typed tasks * Fix SD_task_get_execution_time() to return seconds, not flop*sec * In DAX loader, accept useless 'level' attributes to since LIGO DAGs have them (seem to be to ease graphical representation). MSG: * Add an example masterslave_mailbox.c using send/receive and not the deprecated put/get interface. * Kill the MSG_paje_output() function. It's a noop since 2 years. * Kill MSG_WARNING and MSG_FATAL return codes: they were not used anywere in source. * Rename MSG_TIMEOUT_FAILURE into MSG_TIMEOUT for sake of logic (declare MSG_USE_DEPRECATED to still have the old name) * Add a MSG_task_set_data() function * About trace replay (see examples/msg/actions): - implement barrier - Allow to work with splitted trace files for each process Give the specific trace file as argument of each process, and call MSG_action_trace_run(NULL) You can still have one merged file for all processes. - Fix implementation of collective operations * Allow task_execute() on 0-sized tasks (closes #10063) SMPI: * This is the first release of SimGrid where SMPI is not considered beta anymore (even if some corners should still be improved) * Port over the new SIMIX_network submodule (internal refactoring) * Basic support to log events as with SMPE (use --cfg=SMPE:1) * Implement more missing elements of the standard: - MPI_COMM_SELF - MPI_MAXLOC MPI_MINLOC + all associated datatype MPI_DOUBLE_INT, MPI_FLOAT_INT, etc. - MPI_Address() MPI_Get_count() MPI_Type_free() MPI_Type_extent() MPI_Scan() MPI_Get_processor_name() - Added implementation of missing case for Alltoall (warning: it's *not* the bruck variant from OpenMPI; based on Alltoallv instead) - SMPI_MPI_Gather() SMPI_MPI_Gatherv() SMPI_MPI_Scatterv() SMPI_MPI_Reduce_scatter() SMPI_MPI_Allgather() SMPI_MPI_Allgatherv() * Bug fixes include: - MPI_Waitsome() was broken - Allow relative includes in smpicc - Command line cfg argument 'reference_speed' was ignored... - Some functions did not properly lead to auto-benching of user code - smpicc passes -O2 by default (just like openmpi one) SIMIX: * add SIMIX_action_suspend() and SIMIX_action_resume() functions * Bug fixes about timeouts during communications * add SIMIX_message_sizes_output() as a pimple to write to file the amount of messages per size. Use gnuplot to get histogram. Pimple because that's the only user-visible function of simix, defined directly in xbt.h (irk, sorry) * About semaphores: - Add a SIMIX_sem_get_capacity() function - Fix interactions with processe resume/suspende - release_forever() was stupidly broken - Fix SIMIX_display_process_status() for processes in a semaphore - Make SIMIX_sem_block_onto() user-visible * Refactoring context stuff: - Use pseudo-OOP for better modularity - reimplement SIMIX_process_kill() without process_schedule() so that the latter can take as invariant that it is called from maestro. - Merge context_start into context_new for sake of simplicity SURF: * Add a Vivaldi network model, coded live during SUD'10 ;) * Rename configuration variables to start a hierarchy: o cpu_model -> cpu/model o network_model -> network/model o workstation_model -> workstation/model * New configuration variables: o network/bandwidth_factor: correction to bandwith o network/latency_factor: correction to latency o netwotk/weight_S: correction to the weight of competing streams * Add a long description to the models, that users can see with such argument on the command line: --cfg=cpu/model:help * --help-models display the long description of all known models XBT: * config: add the ability to set a default value after registration Does not override any previously set value (e.g. from cmd line) * dict: allow to have integer key and data. When so, you need to use the following functions void xbt_dicti_set(xbt_dict_t dict, uintptr_t key, uintptr_t data); uintptr_t xbt_dicti_get(xbt_dict_t dict, uintptr_t key); void xbt_dicti_remove(xbt_dict_t dict, uintptr_t key); In contrary to regular dicts, the key is not malloced before copy. Mixing scalar and regular elements in the same dict is not tested (but may work). * Allow to use xbt_dynar_shrink() to expend the dynar instead Tracing for Visualization: * SimGrid is now instrumented in order to generate a trace file for visualization analysis: to use it, need to compile SimGrid with the "tracing" option enabled, and instrument the program using SimGrid with TRACE_start, TRACE_category, TRACE_msg_set_task_category and TRACE_end (among other functions). * The instrumentation only traces the platform utilization for now * Documentation to use the tracing functions and how to analyze the traces with the Triva tool is written. * More information about: SimGrid FAQ (in the section Tracing Simulations for Visualization) Build system: * We moved to cmake as default build system. Autotools support will be dropped soon. Check the FAQ for more info about how to use it. * Greatly improved our cdash/ctest interactions Check http://cdash.inria.fr/CDash/index.php?project=Simgrid * Added memory checking tests with valgrind; lot of memleak fixing. This may be the first release of simgrid with so few memory issues * Added code coverage tests. Our coverage is still improvable, but at least we see it on cdash. -- Da SimGrid team Wed, 28 Apr 2010 28 17:11:16 +0100 SimGrid (3.3.4) stable; urgency=low The "Desktop Grid needs love too" release (also called Xmas release). Models improvements: * Major speedup in the maxmin system solving by using lazy evaluation Instead of solving completely the maxmin system at each iteration, only invalidate (and recompute) the modified parts. This new feature is enabled in default models but you can try to turn it on with "--cfg:maxmin-selective-update=1" for other models. * Cas01 IMproved as default CPU model This CPU model is the same Cas01 model, but it uses the maxmin-selective-update flag and a heap structure to manage actions on SURF kernel. It reduces the complexity to find the next action to finish and, consequently, it's faster than the old Cas01. This is the new default CPU model (Cas01). * Rename the old Cas01 model to Cas01_fullupdate Keep the old cpu model Cas01 with the new name of Cas01_fullupdate. Use "--cfg=cpu_model:Cas01_fullupdate" to use the old default CPU model. * CpuTI (CPU Trace Integration) A new CPU model whose objective is simulate faster when using availability trace files. Instead of using a full featured, over engineered maxmin system for CPU modeling, this model does the pre-integration of traces files to calculate the amount of CPU power available, and so, executes faster than the old CPU models. Use "--cfg=cpu_model:CpuTI" to change to this CPU model. * Use LV08 as default network model since it gives better accuracy for small messages and shouldn't change things for big ones. Use --cfg=network_model:CM02 to get the previous behavior. ****************************************** *DO NOT MIX 3.3.4 RESULTS WITH OLDER ONES* ****************************************** * The new CPU model may changes simulations! The point is that events occurring at the exact same timestamp are not scheduled in the same order with the old and new version. This may be enough to completely change the execution of simulations in some cases. * The new network model will change simulations! This new model is more realistic than the previous one, so you should consider redoing your old experiments with this model. Sorry for the inconvenience. Build System: * Introduce the supernovae compilation mode When compiled that way, the whole SimGrid (or almost) is put in a single compilation unit and compiled in one shoot. This is to help gcc which has difficulties to inline stuff from one file into another. The speedup seem to be above 15%, althrough more tests are needed on amd64 to confirm that gain. MSG: * Port of MSG's mailbox on top of SIMIX network The put/get mechanism was greatly simplified on the way. SIMIX: * New SIMIX network module. Provides: - Mailbox: rendez-vous mecanism to find with who you want to speak - Synchronous send/recv: easier and hopefully faster since the logic is handled in the maestro process directly now - Asynchronous send/recv: you dreamt of it? It's here now Too bad that nobody cared enough to propagate the change to MSG. * Add semaphores as SIMIX synchronization mechanism. SimDag: * new function SD_daxload(char*) to load a DAX file (see http://vtcpc.isi.edu/pegasus/index.php/WorkflowGenerator) * Introduce typed tasks. Specify its kind and cost at creation. At scheduling, just give where it should be placed, and the cost for each involved resource is automatically computed. Existing constructors so far (more to come of course): - SD_task_create_comm_e2e() for end-to-end communication - SD_task_create_comp_seq() for sequential computation Use SD_task_schedulev() / SD_task_schedulel() to schedule them. * new function SD_task_dump() for debuging display * new function SD_task_dotty(task,FILE*) writing to file the info about the task in dotty format * SD_task_dependency_exists() can now cope with having one of its arguments NULL. If so, it tests whether the other argument has any dependency. * Add getters on list of preceding/following tasks: SD_task_get_parents(task) and SD_task_get_children(task) * Add getters on amount of workstations and list: SD_task_get_workstation_count(t) and SD_task_get_workstation_list(t) * Add getter on task kind: SD_task_get_kind(task) * Update the start_time and finish_time of tasks on completion/failure * Bugfix: Remove task from state swags when destroyed GRAS: * New function: void gras_cpu_burn(double flops) -- a simple CPU burner XBT: * New function: xbt_dynar_dopar(dynar,fun) to map a function over the dynar with one separate thread per value of the dynar. * Change the prototype of xbt_thread_create(), sorry. Added a boolean parameter indicating whether we want to join this thread (used in SG only for now) * Implement xbt_thread_join and xbt_thread_yield in SG also. Bug fixes: * GTNetS wrappers should now be usable again (and betterly tested too) * Fix a major regression from 3.2 where the timeout provided to MSG_task_put_with_timeout() was used as absolute time before which the comm should be done. * Start to fix the tag. - Internal links should be good now (beside of the loopback, which use the private link instead) - paths to the external world is still rather broken - the tag is just broken. Actually that's brain-dead. We need sth like to make it less stupid ** Check your platform with teshsuite/simdag/platforms/flatifier ** * Fix a source-level compatibility glitch from 3.2: after defining MSG_USE_DEPRECATED, you can use the old name MSG_task_put_with_time_out() for MSG_task_put_with_timeout() * Allow to compile from the SVN with automake 1.11 * Fix some problems when using the "start_time" tag in deployment XMLs. * Fix #8569: XBT/synchro.h has redundant declarations * Fix #8563: MSG return values and exceptions Introduce a MSG_TIMEOUT_FAILURE return code and use it consistently. * Integrate patch #8636: Obey DESTDIR when installing documentation. Thanks to Robson Peixoto. * Fix a vicious bug in dictionaries inducing that some elements were not freed on xbt_dict_free() Portability report of this version: * Main portability targets: - linux (ubuntu (804/810/910) /debian (4/5/testing) /fedora (core11)) on (amd64/i386/ia64) - mac leopard on i386 Known problems: http://cdash.inria.fr/CDash/index.php?project=Simgrid but nothing critical. * Other platforms: windows, AIX and others were not tested for this release Timing report of this version: * Lazy evaluation brings arbitrary speedup (ie, speedup depending on scenario parameters). From 8h to a few seconds in desktop grid settings. * Supernovae brings about 25% speedup on i386. -- Da SimGrid team Thu, 24 Dec 2009 19:07:39 +0100 SimGrid (3.3.3) stable; urgency=low The "Need for Speed" release. The timings done to validate the 3.3.2 were faulty. Instead of being 5% faster, it was 15% slower (compared to 3.3.1). The problem was a conversion from a manually handled vector to xbt_dynar_t on the critical path. xbt_dynar_foreach calls functions, inducing stack management crap. We inlined these functions and xbt_dynar_foreach is now breath taking. We also inlined xbt_swag_belong on the way. Here are some approximate speedup measurements (on master/slaves simulations lasting between 10s and 20s each): 3.3.1 -> 3.3.2: about same performance 3.3.2 -> 3.3.3: 40% speedup 3.3.1 -> 3.3.3: 40% speedup 3.3.1 with inline patch -> 3.3.3: 30% speedup Our reading is that the refactoring which occurred in 3.3.2 made us suffer much more from the xbt_dynar_foreach low performance, but once we solved this, this refactoring proved to be very performance effective. From the 40% speedup, somehow, 10% are due to the inlining and 30% to the refactoring. That's a pitty that gcc cannot inline functions placed in other files alone. We have to choose between: - break the encapsulation (by putting private data structures and accessors in headers files to help gcc) - live with low performance - switch to a decent compiler such as icc (not quite possible). -- Da SimGrid team Thu, 20 Aug 2009 21:21:33 +0200 SimGrid (3.3.2) stable; urgency=low The "Simplicity does not preceed complexity, but follows it" release. The main contributors of this release were (lexical order): Silas De Munck, Stéphane Genaud, Martin Quinson, Cristian Rosa. SURF: * Extract the routing logic into its own object. (was dupplicated in network.c and workstation_LV07.c; Allows to implement other ways of storing that info) => kill now useless network_card concept - Use dynar to represent routes (instead of void** + int*) - kill link_set (use surf_network_model->resource_set instead) - Add a command-line option to choose the routing schema to use - Add three new models: * Floyd (shortest path computed at initialization) * Dijikstra (shortest path recomputed all the time) * Cached Dijikstra (shortest path computed on need) All these models where contributed by Silas De Munck, and are described in his ICCS09 paper. * Simplify model declaration (less redirections, less function to write when defining a model) - Factorize stuff between models: - model_init/exit - Set of resources: surf_model_resource_set(model) surf_model_resource_by_name(model, name) - Unify the types of models in s_surf_model_t (using an union) - Embeed fields of common_public directly into s_surf_model_t - Rename model methods: action_free ~> action_unref action_change_state ~> action_state_set action_get_state ~> action_state_get - Change model methods into functions : (model)->common_public->action_use ~> surf_action_ref * Implement a generic resource; use it as ancestor to specific ones (allows to kill duplicated code in models) Drawback: timer command don't need no name nor properties; workstation_CLM03 don't need no properties (but I guess we can live with those few bytes wasted) * Improve the action object model - implement a constructor avoiding dupplicated code about field initialization in generic_action part. * Kill the SDP model: it has an external dependency, is deprecated in flavor of modern lmm models, and didn't compile since a while SIMIX: * Relocation of the context module from XBT to SIMIX. (the context were decoupled from the simix processes, duplicating a lot of code) => a lot of code was factorized - less overhead is introduced during scheduling - simpler API for the context factory - the logic for process creation,destruction and manipulation was simplified * Simplification of the s_smx_process_t data structure. => accesing the simix level data associated to a process is faster now, and the code is a lot more readable. SMPI: * Implement some more MPI primitives: MPI_Bcast, MPI_Waitany, MPI_Waitall, MPI_Reduce, MPI_Allreduce, MPI_Scatter, MPI_Sendrecv, MPI_Alltoall -implementation: Bcast: flat or 2-ary tree (default), Barrier: 4-ary tree, Reduce: flat tree Allreduce: Reduce then Bcast Alltoall: "basic_linear" if data per proc < 3Kb, "otherwise pairwise". Not yet implemented: "Bruck" for data per proc < 200b and comm size > 12 Alltoallv: flat tree, like ompi Scatter: flat tree * Add support for optimized collectives (Bcast is now binomial by default) * Port smpirun and smpicc to OS X SimDag: * Kill SD_link_get_properties: hard to maintain and makes very little sense Shout out if you used it. GRAS: * Display the list of still queued messages in SG mode when existing the process. XBT: * Add xbt_set_get_by_name_or_null() [Silas De Munck] * Add xbt_graph_node_get_outedges() [Silas De Munck] * Add xbt_str_from_file(FILE*) * Add xbt_dict_get_key achieving a linear reverse search * Remove the context module Portability report of this version: * Main portability targets: - Linux(debian)/x86/context - Linux(debian)/x86/pthreads - Linux(debian)/amd64/context - Linux(debian)/amd64/pthreads On these, we still have the eratic breakages of gras/pmm and amok/saturate_sg reported in previous version. We still think that the tests are the cause of the fault, not the tested code. - Mac OSX Leopard/x86/context Still false negative in tesh autotesting. Smpi still fails, but this time because readlink does not accept -f Everything seems to work properly beside of that. * Exotic platforms: - AIX version 5.3 (only tested contexts this time) Smpi still fails there because mktemp is not installed. Everything seems to work properly beside of that. - OpenSolaris 11 I managed to compile it for the first time, but several breakages. Won't delay the release for this exotic platform. * Windows: it's still lagging behind. If you want to help, please stand up. Timing report of this version: This version seem to be more than 5% faster than 3.3.1 (on linux 64bits with contextes). The gain is less than expected, we are investigating this for next release. -- Da SimGrid team Wed, 19 Aug 2009 17:07:12 +0200 SimGrid (3.3.1) stable; urgency=low OVERALL CHANGES: * Implement a --cfg-help to show existing configuration variables * Build chain do not require doxygen in maintainer mode GRAS: * fix a bug on struct sizeof computation, which prevented the exchange of arrays of structs in some conditions - added a regression test about this in datadesc_usage * Allow the exchange of 0-long dynamic vectors. - for that, use -1 as indicator of dynamic size instead of 0 - This implied to change any size from unsigned long to long, reducing a bit communication abilities, but I guess that with 64bits being quite common, this is more than enough. - This also induce a protocol change, thus bumping network protocol version from 0 to 1 (if we have external users, we have to get clean on that point too ;) - added two regression tests about this in datadesc_usage * Be more verbose when propagating local exceptions This helps debugging. * Display the status of simulated processes when receiving SIGINT in simulation mode MSG: * Allow to control the simulation from a trace file. New functions MSG_action_register() and MSG_action_trace_run() The first one allows to associate a function execution to each kind of action while the second one parses a trace file and triggers the corresponding actions within the system. For now, only a toy example is provided in examples/msg/actions * Add an exemple of process migration in examples/msg/migration * Fix a bug in task exchange which broke MSG_task_get_sender() Add a teshsuite regression test for that. [Bug: if MSG_task_get_sender() is called after sender exit, bad things happen] * Fix a bug which prevented suspend/resume to work properly * Display the status of simulated processes when receiving SIGINT This fixes a regression of v3.3. due to the introduction of SIMIX * Bug fixing in failure management: - trace could not start by a failure at time 0 - failure during communications were not working SIMIX: * Add SIMIX_process_set_name() to change the name of the current process in the log messages. * Store smx_hosts in a dict since we only retrieve them by name * Move the configuration infrastructure to surf SIMDAG: * Move the configuration infrastructure to surf SMPI: * Massive internal cleanups: - Store internal structures on processes instead of hosts (allows to have more than one process per host, in addition of being more logical) - Cleanup the initialization/finalization process - Kill a whole bunch of unneeded synchronization: processes run in exclusive manner within the simulator - Move queues from global tables to process data fields * Improve smpirun: - now accept -platform and -hostfile arguments - Pass the right rank value to processes according to the hostfile * Compile the examples by default, and use them as regression tests * Implement MPI_Wtime() * Change the reference speed to a command line option SURF: * TCP_gamma can now be specified as command line option using --cfg=TCP_gamma:10000000.0 * Change the --surf-path cmd line option into --cfg=path: XBT: * Also include strbuff from xbt.h public header * xbt_ex_display(): do not free the exception after displaying This allows to do more with the given exception afterward. Users should call xbt_ex_free() themselves. Portability report of this version: * Main portability targets: - Linux(debian)/x86/context - Linux(debian)/x86/pthreads - Linux(debian)/amd64/context - Linux(debian)/amd64/pthreads These targets fail about 1/10 of times on gras/pmm, but we believe that this is because of the test, not because of simgrid. amok/saturate_sg fails even more rarely, and the test may not be the problem. - Mac OSX Leopard/x86/context The test suite still spits tons of errors because some obscure force prevents us from removing the temporary directories arguing that they still contain some metadata I've never heard of. Smpi fails because seq is not installed. Everything seems to work properly beside of that. * Exotic platforms: - AIX version 5.3 (both contexts and pthread) Smpi still fails there because mktemp is not installed. XML inclusions seems rosty on AIX. * Windows: it's still lagging behind. If you want to help, please stand up. -- Da SimGrid team Sat, 27 Jun 2009 00:14:30 +0200 SimGrid (3.3) stable; urgency=high OVERALL CHANGES: * JAVA BINDINGS for MSG (you dreamt of them? We made them) [Malek Cherier & Mt] * Introduce the SIMIX module: factorize code between MSG and GRAS. [Bruno Donassolo] Until now, GRAS were using MSG as an interface to SURF. It was quite difficult because both interface have several differences (MSG channels vs GRAS sockets were the most notable point). This also opens the gate to SMPI (which should occur soon) and speed up simulations by to 40% (even if it were not the main goal). ************************************** *DO NOT MIX 3.2 RESULTS WITH 3.3 ONES* Simix may changes simulations! ************************************** The point is that events occuring at the exact same timestamp are not scheduled in the same order with the old and new version. This may be enough to completely change the execution of simulations in some cases. Sorry for the inconvenience. * Cleanup and upgrade the XML format to push further scalability issues (check http://hal.inria.fr/inria-00256883/ for more info) * Improve the testing infrastructure with tesh. Now a very large part of the code is tested not only by being run but also by checking that the output match an expected output [Mt]. * Move on to FleXML v1.7 for the embeeded XML parsers. This version is really less memory-demanding, which should allow you to use larger files in SimGrid [AL]. * Inform valgrind about our contextes, so that it becomes usable with the default (and more effecient) version of SimGrid [contributed by Sékou Diakite, many thanks] GRAS: * Introduce a listener thread in charge of receiving incoming messages from the network. It allows to overlap communication and computation but most notably, it removes some stupid deadlocks due to the fact that so far, a process could not send and receive at the same time. This made most non trivial communication schema impossible. * Convert the PIDs from long int to int to match the MSG ones (and linux ones too) [Mt] * New function: gras_agent_spawn() to launch a new process on current host. Only working in simulation for now. [Mt] * New function: gras_os_hostport() returning a constant form (ie, not needing to be freed) of "gras_os_hostname():gras_os_myport()" XBT: * Make the backtrace of exceptions more human readable [Mt] * New module: xbt/str [Mt] a ton of string utility functions (split, join, printf to a newly allocated buffer, trim, etc) * New module: xbt/hash [Mt] SHA1 hashing algorithm (more to come if needed) * New module: xbt/synchro [Mt] synchronization tools (mutex and conditions) working the same way in simulation and in real life (mainly useful for GRAS, but not only). * New module: xbt/queue [Mt] classical producer/consumer synchronization scheme * xbt_dynar_new_sync() creates a synchronized dynar. All access (using the classical functions will get serialized) [Mt] * Make dictionary internal table dynamic. No need to specify its size anymore; functions xbt_dict_new_ext() and xbt_dict_hashsize_set() thus dropped. [Mt]. * Make sure the log channels are organized as a tree under windows (because of ANSI C compatibility issue, any channel were child of root directly) [Mt]. SURF: * Cleaned many thing in surf and fixed a few bugs [AL]. * Add a nice command line configuration mechanism to compose models [AL]. * Add a new model for parallel tasks (ptask_L07) that is less buggy than the previous one (KCCFLN05). It relies on something that looks like a max-min sharing mechanism but cannot be written as such. A new solver was thus designed [AL]. * Add a new solver to lmm. Based on Lagrange optimization and gradient-based descent, it enables to efficiently maximise systems s.a sum f_i(x_i) s.t Ax<= b with A_{i,j}>=0 and f_i a concave function. This solver enables to propose two new network models for TCP Reno and TCP Vegas based on Low's work. These models still need to be fully tested though [Pedro Velho]. SIMDAG [AL]: * Bug fix in SD_simulate. Now the time bound given as argument is used. * Use the new parallel task model (ptask_L07) as default. * Use the SURF command line configuration mechanism. * 0-size tasks (for synchronization) should now work. -- Da SimGrid team Sun Apr 12 05:20:36 CEST 2009 SimGrid (3.2) stable; urgency=high OVERALL CHANGES: * Port to windows. We still experience issues on this platform, but we believe that at least MSG is usable. GRAS API BREAKAGE (for simplification purpose, sorry): * the gras_msgtype_by_name is not used anymore. Instead of gras_msg_send(toserver, gras_msgtype_by_name("request"), &request); you can write (and must) gras_msg_send(toserver, "request", &request); - If you still want to pass a gras_msgtype_t to the function (to cache the type and avoid the lookup time), use the gras_msg_send_() variant. - Impacted functions: gras_cb_register, gras_cb_unregister, gras_msg_send, gras_msg_wait, gras_msg_rpccall, gras_msg_rpc_async_call, gras_msg_wait_ext * The callbacks are now expected to return 0 when everything went well (just like the main() function) GRAS new features and improvements: * New module mecanism where user code can use per process globals [Mt] This is similar to gras_userdata_*() functions, but for libraries. It factorize some code developped over and over in the examples and AMOK. It has still to be documented and used (only amok/peermanagement is converted for now). * Fix a vicious bug in the TCP buffering mecanism which leaded to message loss when they were small enough to fit into the buffer and sent quickly enough so that they can all get received in one shoot. * gras_datadesc_by_name and gras_msgtype_by_name: now raise an exception if not found. Use the *_or_null() variant for the old semantic. * In gras_msg_handle, do not discard messages without callback. They are probably messages to be explicitly awaited later (ie, proofs of mis-synchronization in userland since they are sent before being awaited) No big deal usually. * gras_socket_meas_send/recv: semantic changed! The numerical arguments used to be (1) the total amount of data to send and (2) msg_size. This was changed to (1) msg_size and (2) amount of messages. This was need for the fool willing to send more than MAXINT bytes on quite fat pipes. AMOK: * Do really rename the hostmanagement module to peermanagement. [Mt] Ie, rename functions from amok_hm_* to amok_pm_*. This breaks the API, but this is rather new and this was documented in the module documentation (poor excuses, I admit) * Bandwidth measurement semantic changed! This follows the changes to gras_socket_meas_send/recv explained above. SIMDAG: * A sequential mode has been added to the workstations. When a workstation is in sequential mode, it can execute only one task, and the other tasks are waiting in a FIFO. [Christophe Thiery] SURF: * The KCCFLN05 workstation model now handles parallel tasks. It is the model for SIMDAG. [Christophe Thiery] * Bug fix in the maxmin solver: Some values were close to 0 instead of equal to 0, which caused some bad behaviors in saturated_constraint_set_update. I now use a threshold mechanism like in surf. [AL] XBT: * When running manually src/testall, you select specific units [Mt] testall is the result of our cunit mecanism, and should replace all the scripty thingy around since bash don't run easily on billware. * A mallocator system has been added. [Christophe Thiery] Mallocators allow you to recycle your unused objects instead of freeing them and allocating new ones. Documentation update: * FAQ reworking + New FAQs: - "Valgrind spits tons of errors!" [Mt] - "How to repport bugs" [Mt] - "Cross-compiling a Windows DLL of SimGrid from Linux" [Mt] - "What is the difference between MSG, SimDag, and GRAS?" [Mt] - Communication time measurement within MSG [AL] - I experience weird communication times when I change the latency [AL] * GRAS tutorial [Mt] It contains: - an introduction to the framework and to the used communication model - an initiatic tour introducing the most proheminent features: o Part 1: Bases . Lesson 0: Installing GRAS . Lesson 1: Setting up your own project o Part 2: Message passing . Lesson 2: Exchanging simple messages . Lesson 3: Passing arguments to the processes (in SG) . Lesson 4: Attaching callbacks to messages . Lesson 5: Using globals in processes . Lesson 6: Logging informations properly . Lesson 7: Using internal timers . Lesson 8: Handling errors through exceptions . Lesson 9: Exchanging simple data . Lesson 10: Remote Procedure Calling (RPC) . Lesson 11: Explicitely waiting for messages . Recapping of message passing features in GRAS - A HOWTO section containing: o HOWTO design a GRAS application More are due, of course. They will come latter. In the meanwhile, you can check the examples which are still here. -- Da SimGrid team Fri Mar 16 21:11:46 CET 2007 SimGrid (3.1) stable; urgency=high General: * Port to gcc 4.x There was a stack corruption somewhere, visible only when optimizing with these versions. [Vince] SIMDAG: * This is a NEW module! SimDAG (SD for short) is a revival of the old SG module that enabled to play with Directed Acyclic Graphs. It is built directly on top of SURF and provides an API rather close to the old SG. Some old codes using SG are currently under rewrite to check that all needful functions are provided. [Christophe Thiery] SURF: * Complete rewrite of the KCCFLN05 workstation model. It is now an extension of the classical CLM03 model that gracefully handles failures. This is now the default model for MSG and GRAS. It doesn't handle parallel tasks yet though. [AL] * Bug fix: Weights were not correctly set in the network part. WARNING: This may have resulted in incorrect results with simulations where there are more than one flow on a given link. [AL] SURF, MSG, GRAS: * After a (long ?) discussion on simgrid-devel, we have decided that the convention we had on units was stupid. That is why it has been decided to move from (MBits, MFlops, seconds) to (Bits, Flops, seconds). WARNING : This means that all previous platform files will not work as such with this version! A warning is issued to ask users to update their files. [AL] A conversion script can be found in the contrib module of the CVS, under the name contrib/platform_generation/surfxml_update.pl [MQ] MSG,GRAS: * Bug fix: Processes were started in reverse order, wrt deployment file. WARNING: if your code relies on this bug, please fix it. [AL] * Bug fix: Add a test in MSG_task_execute to stop whenever a task is being executed on two different locations. [AL] * Bug fix: Failures are now better supported thanks to Derrick's tests (there was many failure situations I hadn't thought of and that weren't correctly handled). [AL] * New function: MSG_host_is_avail indicates you whether a given m_host_t is up or down. [AL] GRAS: * New! a real RPC mecanism, as it ought to be since too long. [MQ] Exception occurring on server-side are propagated back to client (!). API CHANGE: the callback changed their prototype. Change: int my_handler(gras_socket_t expeditor, void *payload_data) { to: int my_handler(gras_msg_cb_ctx_t ctx , void *payload_data) { gras_socket_t expeditor=gras_msg_cb_ctx_from(ctx); and you're set. * New! function: gras_msg_handleall to deal with all messages arriving within a given period. * New! function: gras_socket_server_range to get a server socket in a range of port numbers (ease to avoid port number conflicts) [MQ] * New! gras processes display their backtrace when they get a SIGUSR1 or when Ctrl-C is pressed. Use Ctrl-C Ctrl-C to exit. Sweet to debug RL processes [MQ] AMOK: * Bandwidth module: - Do not force experiment sizes to be expressed in kb, or it becomes impossible to measure the latency this way (needs one byte-long tests) WARNING: this changes the amok_bw_* function semantic. [MQ] - Implements the link saturation stuff. [MQ] * Peer management module: New! module factorizing code that we wrote over and over [MQ]. XBT: * New module: cunit (my jUnit implementation in ansi C) [MQ] - Test units are placed directly into the library code, they get extracted automatically and placed into the src/testall binary. - Convert most of the XBT tests to this system. * New functions: xbt_dynar_getfirst_as() and xbt_dynar_getlast_as() [MQ] * XML parsing: rewrote parts of flexml to enable multiple xml parsers to live in the same C code. This required to change a little bit the API of surfxml parsing but shouldn't be an issue for end-users. [AL] * New module: sparse graph structure with basic algorithms (this is work in progress and the API is not considered to be frozen yet). [AL] * Display more information on backtraces: source line & function names are now displayed just like valgrind does (rely on addr2line tool) [MQ] * New function: xbt_backtrace_display(). Sweet while debuging [MQ] * Reworked a little bit some #include statements to load only required headers. Some user code that relied on SimGrid to include stdlib or stdio may need to include it by themselves. [AL] * Fixed xbt/log.h. A missing SG_BEGIN_DECL prevented compilation with g++. [AL] * Renamed xbt_host_t into xbt_peer_t since it betterly describes what I meant. This breaks the API of AMOK and of xbt/config. Sorry about this, but I guess that almost nobody used those parts. [MQ] -- Da SimGrid team Fri, 14 Jul 2006 01:32:27 +0200 SimGrid (3.0.1) stable; urgency=low XBT: * Unfortunately, I had missed 5 misnamed functions: xbt_fifo_item_t xbt_fifo_newitem(void); void xbt_fifo_freeitem(xbt_fifo_item_t); xbt_fifo_item_t xbt_fifo_getFirstItem(xbt_fifo_t l); xbt_fifo_item_t xbt_fifo_getNextItem(xbt_fifo_item_t i); xbt_fifo_item_t xbt_fifo_getPrevItem(xbt_fifo_item_t i); They're now deprecated. Please use their new versions: xbt_fifo_item_t xbt_fifo_new_item(void); void xbt_fifo_free_item(xbt_fifo_item_t); xbt_fifo_item_t xbt_fifo_get_first_item(xbt_fifo_t l); xbt_fifo_item_t xbt_fifo_get_next_item(xbt_fifo_item_t i); xbt_fifo_item_t xbt_fifo_get_prev_item(xbt_fifo_item_t i); [AL] * Bugfix: really disconnect fifo items which are remove_item()ed [AL] * Documentation: xbt_log module unmercifully reworked [MQ] * Bugfix: there was a problem with the ending of contexts with the pthread backend. It caused some weird deadlock or behavior depending on the pthread implementation. [AL] * Bugfix: get the exceptions raised in the simulator repport where and why they come from when they are not catched in time [AL, MQ] SURF: * Bugfix: Do repport the error when two non-connected hosts try to exchange data (Thanks to Flavien for stumbling into this one) [AL] SURF: * Add additionnal checkings on communications. Assert that two communicating hosts are connected by a set of links... [AL] MSG: * Add additionnal checkings on channel values in communication [AL] * New: MSG_task_get_source to see on which host a task was generated [HC] * New: int MSG_task_probe_from_host(int channel, m_host_t host): returns the number of tasks waiting to be received on channel and sent by host. [AL] * New: MSG_error_t MSG_task_get_from_host(m_task_t * task, int channel, m_host_t host); waits for the first task coming from a given host.. [AL] GRAS new functionnalities: [MQ] * Enhance the parsing macro to allow the size of multidimentional objects to be given thru annotations. * New example (and documentation): Matrix Multiplication a la RPC (as when I was young!) and fix a bunch of bugs found on the way. GRAS performance improvements: [MQ] [DataDesc] * Reduce the amount of cbps creation/destruction by making it static to datadesc_send/recv() and using a (newly created) cbps_reset (based on dynar_reset ()) [Virtu] * Change libdata to a set so that we can search for stuff by ID (and thus reduce the insane amount of dict lookups) [Transport] * Actually implement gras_datadesc_copy() so that we don't have to mimick RL communication on top of SG since it's so uneffective. It may also be used for inter-thread communication in RL, one day. * Use gras_datadesc_copy() to exchange messages on top of SG Allows to: - improve message exchange performance on top of SG - deprecate transport_plugin_sg.c:gras_trp_sg_chunk_send() & recv() * Don't exchange on the network the size of the used part of buffer, instead, specify the possible buffer size to read(). Advantages: - reduces the amount of read/write calls (one pair per exchange) - reduces the amount of exchanged data (the size) - allows to retrieve all arrived data on receiver side, if we don't need it right now (subsequent read will peek the buffer) - allows the receiver to proceed with the begining of the stream before everything is arrived - make it possible to build an iov transport (using readv/writev) Extra difficulty: - take care of the data with non-stable storage (like stacked data), and bufferize them. * If possible, TCP send uses vector I/O (when writev() is here) - Don't use it for receive since we send data sizes and data on the same stream, so we wouldn't be able to chain large amount of chunks before having to flush the stuff to read the size. * Rework the transport plugin mecanism to simplify it and reduce the amount of pointer dereferencement when searching for the right function to use. * I guess that now, we do almost as few system calls as possible while doing as few data copy as possible. To improve it further, we could try to send all the sizes first and then all the data (to use iov on receiving size), but it's only a partial solution: when you have 2 dimensional data, the sizes of the second dimension is data of the first dimension, so you need 3 streams. I'm not sure the potential performance gains justify the coding burden. -- Da SimGrid team Fri, 21 Oct 2005 14:42:20 +0200 SimGrid (3.00) stable; urgency=high SURF: * New! Give the possibility to hijack the surf parser and thus bypass MSG_create_environment and MSG_launch_application. Have a look at examples/msg/msg_test_surfxml_bypassed.c to see how it can be done. -- Arnaud Legrand Sat, 20 Aug 2005 23:25:25 -0700 SimGrid (2.96) unstable; urgency=low AKA SimGrid 3 rc 2. XBT: * New! Exception handling with setjmp or such (code from OSSP ex) [MQ] This deprecates the xbt_error_t mecanisms. It modifies (simplifies) all XBT and GRAS API. MSG API keeps unchanged (exceptions raised by XBT are catched from within MSG and masked with existing error handling facilities) SURF: * New! Add a FATPIPE model. [AL] * New! Add a parallel task model. [AL] * New! Add automatically a loopback interface (in the default network model) if none was precised. MSG * Bugfix: MSG_process_resume now works with the current running process. [AL] * New! Add MSG_parallel_task_create and MSG_parallel_task_execute. [AL] * Modification of MSG_task_get_compute_duration. Once a task has been processed, the value returned by this function is now equal to 0. [AL] * New! Add double MSG_task_get_remaining_computation(m_task_t task) and MSG_error_t MSG_task_cancel(m_task_t task). Add a state (MSG_TASK_CANCELLED) to MSG_error_t corresponding to the cancelation of a m_task. For now, MSG_task_cancel only works with computation tasks. [AL] * New! Add double MSG_get_host_speed(m_host_t h) that returns the speed of the processor (in Mflop/s) regardless of the current load on the machine. [AL] * API Change: use proper naming convention for MSG_getClock and MSG_process_isSuspended: MSG_get_clock and MSG_process_is_suspended. [AL] * New! Add void MSG_task_set_priority(m_task_t task, double priority). This function changes the priority of a computation task. This priority doesn't affect the transfer rate. A priority of 2 will make a task receive two times more cpu power than the other ones. This function has been added to suit the needs of Nguyen The Loc and hasn't been that much tested yet. So if it fails, please report it and send me your code. [AL] * API Change: removed all functions and types that were marked "deprecated" since many months. Renamed MSG_global_init_args to MSG_global_init. -- Da SimGrid team Mon, 8 Aug 2005 17:58:47 -0700 SimGrid (2.95) unstable; urgency=low XBT * Steal some nice code to GNU pth to fix context detection and usage [AL] * Cleanup in the xbt_config API; add configuration callbacks. [MQ] * Cleanup in the initialization API: the unused "defaultlog" is dead. [MQ] SURF * Bugfix: Allow absolute paths for platform description files [MQ] * Bugfix: do free the variables after use. Leads to drastic performance improvement [AL] * Implement max_duration (ie, timeouts) on resources [AL] MSG * Implement MSG_config to configure MSG at runtime. xbt_cfg test on a real case ;) [MQ] * Implement MSG_channel_select_from() to help GRAS now that SURF provide the needed support (timeouts) [AL] GRAS (new features) * Implement measurement sockets. You can now get the bandwidth between two hosts thanks to AMOK (see below). [MQ] * gras_datadesc_dynar() builds a dynar type descriptor, allowing to send dynar over the network (yeah) [MQ] * Real (even if simplistic) implementation of gras_os_myname() on RL [MQ] * simple/static token-ring example. [Alexandre Colucci and MQ] * Use MSG_channel_select_from() and remove the *slow* hack we had to put in place before [MQ] GRAS (bug fixes) * Differentiate the types "char[22]" and "unsigned char[22]" in automatic type parsing. "short" and "long" modifiers were also ignored; other modifier (such as reference level) are still ignored. [MQ] * Embeed the buffer size within the buffer itself on SG. [MQ] That way, send() are atomic and cannot get intermixed anymore (at least the ones which are less than 100k; bigger messages still have the issue) * Array size pushed by the field, not by the field type (or each and every long int will push stuff to the cbps) [MQ] * use select() to sleep since it allows to portably sleep less than one second. [MQ] GRAS (minor cleanups) * .Makefile.local (generated from gras_stub_generator) |MQ]: - Do clean .o files - Compile with -g * Type Callbacks now receive the gras_datadesc_type_t they work on as argument. * type category 'ignored' killed as it was never used and were difficult to transmit. * whether a type can cycle or not is now a flag, leaving room for more flags (as "ignored", if we feel the need one day ;) * Rename raw sockets to measurement sockets since "raw" has another meaning in networking community. AMOK * Advanced Metacomputing Overlay Kit introduction. It is based over GRAS and offers features not belonging to GRAS but that most applications need. One day, it may be a set of plugins loadable at runtime. * New module: bandwidth bandwidth measurement between arbitrary nodes running this module. [MQ] -- Da SimGrid team Thu, 30 Jun 2005 16:29:20 -0700 SimGrid (2.94) unstable; urgency=low The first beta release of SimGrid 3 ! >>>Arnaud<<< (documentation) * Update the main page and the FAQ. Adding references to gforge. (gras) * Add a gras_os_getpid function. (msg) * Add MSG_task_get_compute_duration() and MSG_task_get_data_size() * Extend the logs so that they also print PID, hostname, date, ... if available. * Convert the MSG example to the use of xbt_logs instead of PRINT_MESSAGE, and kill the old version which were in testsuite/ * Rewrite tools/MSG_visualization/colorize.pl for using with logs instead of PRINT_MESSAGE (xbt) * Add xbt_os_time(). As the rest of xbt/portability, this is not public for users. Instead, each programming environment (GRAS, MSG,...) use it when needed to provide such a feature to users. Don't shortcut the mecanism or you will also shortcut the virtualization you need on the simulator. >>>Martin<<< (infrastructure) * Cleanups in configury with regard to compile optimization/warning flags. Also add -fno-loop-optimize to any powerpc since it's the optimization killing gcc (< 3.4.0). * Doxygen cleanups: move MSG examples, kill the second Doxygen phase needed by MSG examples complications * Borrow configury beautifications from PHP (xbt) * Bugfix: XBT_LOG_NEW_DEFAULT_CATEGORY now compiles without compiler warning (thanks loris for stumbling into this one). * Bugfix: stop loading private headers (gras_config.h) from the public ones (xbt/swag.h). (gras) * Change SIMGRID_INSTALL_PATH to GRAS_ROOT in Makefiles generated for user. * Rename gras_get_my_fqdn to gras_os_myname and implement it in the simulator RL would imply a DNS resolver, which is *hard* to do in a portable way (and therefore delayed). * Implement a real timer mecanism and use it in timing macros. This allows to avoid rounding errors and get a 0.000005 sec precision in timing macros. While I was at it, various cleanups: - allow to declare more than one timed section per file (fix a stupid bug) - move some private declaration to the right place - merge conditional execution and timing macros into emulation module - document the module - make sure the module cleanups its mess on gras_exit * Documentation improvements: - (new) how to compile applications using GRAS - (new) emulation support (timing macros) -- Da SimGrid team Fri, 13 May 2005 10:49:31 +0200 SimGrid (2.93) unstable; urgency=low Alpha 4 on the path to SimGrid 3 (aka the "neuf-trois" version) [Arnaud] - Use Paje properly where used. Still to be sanitized properly. - Portability fix: Add an implementation of the contexts using pthread [Martin] (misc) - Add xbt_procname(): returns the name of the current process. Use it to show the current process's name in all logging. (infrastructure) - fix detection of older flex version and the reaction, since we do depend on modern ones (we use lex_destroy) - Better separation of SG and RL in the libs: remove all simulation code from libgras. As a result, this lib is now only 200k when stripped. Some of the xbt modules may also be duplicated (two sets and such) and should be cleaned/killed before SG3. - Insist on using xlC on AIX because of weird problems involving gcc there. - Cleanup the make remote stuff. This is now done by scripts tools/graspe-{master,slave} (GRAS Platform Expender). This is still mainly for our private use, but we're working on changing them to user tools, too. (gras) - Bugfix: flush the socket on close only if there is some *output*. - Bugfix: flush idempotent when there's nothing to send (don't send size=0) (msg) - Add MSG_task_get_name. The task names are mainly for debugging purpose, but anyway. -- SimGrid team Fri, 4 Mar 2005 14:32:37 -0800 SimGrid (2.92) unstable; urgency=low Alpha 3 on the path to SimGrid 3 [Arnaud] (gras) - New! First try of benchmarking macros. - New! First try so that gras_stub_generator generate deployment and remote compilation helpers. (msg) - Bugfix: Initialization fix in msg_test. [Martin] (surf) - Bugfix: applied patch to lexer so that it doesn't need a huge heap. (xbt) - Bugfix: let dicts work with NULL content (_foreach didn't) and cleanups (gras) - API Change: gras_os_sleep to take the amount of seconds as a double. Accepting an int was error prone since it was the only location where seconds were coded as such. It leaded to damn rounding errors. - Bugfix: Hard to belive that timers ever worked before this. -- SimGrid team Wed, 23 Feb 2005 22:09:21 +0100 SimGrid (2.91) unstable; urgency=low Alpha 2 on the path to SimGrid 3 [Arnaud] (surf) - Bug fix in the lmm_solver. (msg) - New! Interface to Paje (see http://www-id.imag.fr/Logiciels/paje/) through the function MSG_paje_output. - New! Introducing two new functions MSG_process_kill() and MSG_process_killall(). - It is possible to bound the rate of a communication in MSG with MSG_task_put_bounded() (was already in the previous version but I had forgotten to write it in the changelog). - Bug fix to let GRAS run on top of MSG until we move it directly on top of the SURF. [Martin] (infrastructure) - Various cleanups to the autotools stuff - Begin to move Gras examples to examples/gras/ - Let make distcheck work again (yeah!) (documentation) - documentation overhauled using doxygen. gtk-doc-tools is dead in SimGrid now. - Automatically extract all existing logging categories, and add the list to the documentation (long standing one, to say the less) (gras) - Cleanup the known architecture table. Reorder the entries to group what should be, and use a more consistent naming scheme. (some of the test dataset are still to be regenerated) - New! Allow library to register globals on each process just as userdata does. This is implemented using a xbt_dict and not a xbt_set, so we loose the lookup time (for now). Use it in msg and trp. This cleans a lot the internals and helps enforcing privacy of the headers between the gras components. - New! Add a timer mechanism, not unlike cron(8) and at(1). - Bugfix: gras_os_time was delirious in RL. - Bugfix: gras_trp_select/RL don't run into the wall when asked to select onto 0 sockets. - Reenable GRAS now that it works. -- Arnaud Legrand Mon, 14 Feb 2005 14:02:13 -0800 SimGrid (2.90) unstable; urgency=low Alpha 1 on the path to SimGrid 3 * It is a long time since the last release of SimGrid. I'm sorry about that but as I had told you, I was rewriting a lot of things. I apologize to those who had been reporting bugs to me and that I had not answered. If your bug is still in the new version, please tell me. Here is a summary of the main changes. * REVOLUTION 1: The SimGrid project has merged with the GRAS project lead by Martin Quinson. As a consequence SimGrid gains a lot in portability, speed, and a lot more but you'll figure it out later. SimGrid now comprises 3 different projects : MSG, GRAS and SMPI. I wanted to release the new MSG as soon as possible and I have broken GRAS, which is the reason why, for now, only MSG is fully functional. A laconic description of these projects is available in the documentation. * REVOLUTION 2: I have removed SG and I am now using a new simulation kernel optimized for our needs (called SURF but only the developers should use it). Hence, MSG is now roughly 30 times faster and I think that by rewriting a little bit MSG, I could event speed it up a little bit more. Beside the gain in speed, it is also much easier to encode a new platform model with SURF than it was with SG. More to come... * REVOLUTION 3: I have tried to change a little as possible the API of MSG but a few things really had to disappear. The main differences with the previous version are : 1) no more m_links_t and the corresponding functions. Platforms are directly read from a XML description and cannot be hard-coded anymore. The same format is used for application deployment description. The new format is described in the documentation. Have a look in tools/platform_generation. There is a tiny script that converts from the old platform format to the new one. Concerning the application deployment format, parsing the old one is tricky. I think most of you should however be able to convert your files. If it is really an issue, I can write a C code that does the conversion. Let me know. 2) the toolbox tbx does not exist anymore. We now have a library with much more data-structures but without the hash-tables (we have dictionaries that are much faster). -- Arnaud Legrand Mon, 31 Jan 2005 10:45:53 -0800 ***************************************************************************** * Follows the old GRAS changelog. It does not follow the same syntax, but I * * don't feel like converting the oldies. (Mt) * ***************************************************************************** 2005-01-31 Arnaud Version 2.90: "the long awaited one" - Finished rewriting and debugging MSG. Rewrote the documentation. - disable GRAS for now since it needs to be ported to the newest SG 2004-12-16 Martin - Finish the port to windows (using mingw32 for cross-compile) 2004-11-28 Arnaud - Main loop and datastructures of SURF. A cpu resource object is functional. Surf can thus be used to create cpu's with variable performance on which you can execute some actions. 2004-11-15 Martin Quinson - Port to ARM. Simply added the alignment and size descriptions. Should work, but the ARM machines are so slow that I didn't had the opportunity to 'make check' over there yet. 2004-11-15 Arnaud Legrand - Trace manager now written. It uses a heap structure and is therefore expected to be efficient. It may however be speeded up (particularly when many events occur at the same date) by using red and black trees. One day maybe... - Max-min linear system solver written. It uses a sparse matrix structure taking advantage of its expected use. Most operations are O(1) and free/calloc are called as few as possible. The computation of the minimum could however be improved by using a red and black tree (again ! ;). 2004-11-03 Arnaud Legrand - Rename every gras_* function that was in xbt/ to its xbt_ counterpart. - Add a heap and a doubly-linked list to xbt - Added a dichotomy to the dictionaries. make check works as well before so I assume that the patch is correct. I do not know however if things run effectively faster than before now. :) Inclusion of the SimGrid tree in the GRAS one. The archive is renamed to SimGrid, and the version number is bumped to 2.x 2004-10-29 Martin Quinson - Introduction of the remote errors. They are the result of a RMI/RPC on the remote machine. ErrCodes being scalar values, you can't get the host on which those errors did happen. Extending the error mechanism as in Gnome is possible. No idea yet whether it is a good idea. 2004-10-28 Martin Quinson - Interface revolution: the Starred Structure Eradication. I used to do typedef struct {} toto_t; and then handle *toto_t. Arnaud (and Oli) didn't like it, and I surrendered. Now, you have: - ???_t is a valid type (builded with typedef) - s_toto_t is a structure (access to fields with .) - s_toto is a structure needing 'struct' keyword to be used - e_toto_t is an enum - toto_t is an 'object' (struct*) Exemple: typedef struct s_toto {} s_toto_t, *toto_t; typedef enum {} e_toto_t; Moreover, only toto_t (and e_toto_t) are public. The rest (mainly s_toto_t) is private. - While I was at it, all gras__free() functions want a gras__t* so that it can set the variable to NULL. It was so for dicts and sets, it changed for dynars. - Fix a bunch of memleaks in dict_remove - Fix a bug in sg/server_socket opening: it failed all the time. 2004-10-07 Martin Quinson - Speed up dynar lookup operation a bit. gras_dynar_get is dead. Now, you can choose between gras_dynar_get_cpy (the old gras_dynar_get but should be avoided for efficiency reasons) and gras_dynar_get_ptr (which gives you the address of the stored data). gras_dynar_get_as is an helpful macro which allows you to retrieve a copy of the data using an affectation to do the job and not a memcpy. int toto = gras_dynar_get_as(dyn,0,int); rewrites itself to int toto = *(int*)gras_dynar_get_ptr(dyn,0); It does not really speedup the dynar test because they are setting elements all the time (and look them seldom). But the dict does far more lookup than setting. So, this brings the dict_crash test from ~33s to ~25s (200000 elms). 2004-10-05 Martin Quinson - Allow to (en/dis)able the cycle detection at run time. Whether we should check for cycle or not is now a property of each datatype. When you think there may be some cycle, use datadesc_cycle_set. datadesc_cycle_unset allow to remove this property when previously set. Note that the cycle detection is off by default since it impacts the performance. Watch the data you feed GRAS with ;) This property is hereditary. Any element embedded in a structure having it set have it set for the time of this data exchange. You should set it both on sender and receiver side. If you don't set it on sender side, it will enter an endless loop. If you forget on receiver side, the cycles won't be recreated after communication. - Header reorganization. Kill gras_private.h, each submodule must load the headers it needs. 2004-10-04 Martin Quinson - Interface revolution: do not try to survive to malloc failure. Now, gras_malloc and friends call gras_abort() on failure. As a conclusion, malloc_error is not a valid error anymore, and all functions for which it was the only gras_error_t return value are changed. They now return void, or there result directly. This simplify the API a lot. 2004-09-29 Martin Quinson - Re-enable raw sockets. Created by gras_socket_{client,server}_ext; Used with gras_raw_{send,recv} No select possible. It should allow to kill the last bits of gras first version soon. This is not completely satisfactory yet (duplicate code with chunk_{send,recv}; a bit out of the plugin mechanism), but it should work. - Simplify transport plugin (internal) interface by not passing any argument to _server and _client, but embedding them in the socket struct directly. 2004-09-28 Martin Quinson - Finish the port to AIX. autoconf was my problem (segfault within the malloc replacement function. No idea why) 2004-09-16 Martin Quinson - Fix some size_t madness on 64bit architectures. 2004-09-08 Martin Quinson - Reduce the number of system headers loaded, overload some more system calls (such as malloc to cast the result of the system one, and work properly on AIX) - Fix and reintroduce the config support 2004-09-07 Martin Quinson - Source code reorganization to allow Arnaud to surf all over there. - Allow to document the logging categories. - Remove all uppercase from logging categories and useless cleanup in names. 2004-08-18 Martin Quinson Version 0.6.2 (protocol not changed; API changed) - Interface cleanup: gras_msgtype_by_name returns the type (instead of a gras_error_t), and NULL when not found. Functions expecting a msgtype as argument (msg_wait; msg_send) deal with NULL argument by providing a hopefully usefull message. - Portability to prehistoric sparcs again 2004-08-17 Martin Quinson Version 0.6.1 (protocol not changed; ABI not changed) - prealloc some buffers to speed things up 2004-08-11 Martin Quinson Version 0.6 (protocol not changed; ABI expended) - The parsing macro can deal with the references, provided that you add the relevant annotations (using GRAS_ANNOTE(size,field_name)) 2004-08-09 Martin Quinson Version 0.5 (protocol not changed; ABI changed) - Allow to off turn the cycle detection code in data exchange at compilation time. It should be at run time, but I'm short of time (and the config stuff is still broken). That way, we keep dict out of the critical path, which is good because the performance is poor: - search not dichotomial yet - dynar give no way to access their content and memcpy everytime - In composed data description (struct, ref and so on), stop foolness of keeping the subtype's ID, but store the type itself. This keeps sets out of the critical path, which is good since they rely on dynar and dictionnaries. The only loose of that is that we cannot detect the redeclaration of a structure/union with another content (but I'm not sure the code detected well this error before anyway). We still can detect the redefinition discrepancy for the other types. - Use a whole bunch of optimisation flags (plus -fno-strict-aliasing since it breaks the code because of type-punning used all over the place). This breaks on all non-gcc architectures (for now). All those changes (plus the buffer of last time) allow me to gain 2 order of magnitude on cruel tests consisting of 800000 array of integers on two level of a hierarchical structure (200 secondes -> 4 secondes) API change: - the selector of reference must now return the type it points to, not the ID of this type. 2004-08-06 Martin Quinson Version 0.4 (protocol changed; ABI not changed) - Allow to pass --gras-log argument to processes in simulation mode. Really. - New debugging level: trace (under debug) to see effect of GRAS_IN/OUT - Implement a buffer transport, and use it by default (it relies on tcp in real life and on sg in simulation). That's a bit hackish since I had a new field to the structure to store its data without interfering with the subtype ones. Inheritance is tricky in C. And that's a kind of reverse inheritance with one class derivating two classes. Or maybe a game with java interfaces. Anyway, that's damn hard in C (at least). Moreover, I got tired while trying to ensure plugin separation and genericity in SG mode. MSG wants me to do weird things, so let's go for cruel hacks (temporarily of course ;). See comment in transport_private.h:71 - do not include all the _interface headers in private but in the files which really need them (to cut the compilation time when they are modified) 2004-07-26 Martin Quinson Version 0.3 (protocol not changed; ABI changed) - Major overhault of the datadesc interface to simplify it: - shorted the function names: s/gras_datadesc_declare_struct/gras_datadesc_struct/ and so on - add a trivial way to push/pop integers into the cbps without malloc. This allows to make really generic sub_type description, which simply pop their size of the stack. - add a function gras_datadesc_ref_pop_arr() which does what users want most of the time: Declare a dynamic array (which pops its size of the stack) and declare a reference to it. Poor name, but anyway. - kill the post-send callback, add a post-receive one 2004-07-23 Martin Quinson Version 0.2 (protocol changed; ABI changed) - add some testing for cpbs in the test cases, and fix some more bugs. This invalidate again the little64 data file, since I cannot regenerate it myself. - remove an awfull optimization in the logging stuff, allowing me to: - understand it again - learn gcc how to check that the argument match the provided format - fix all errors revealed by gcc after that - internal keys of dict are not \0 terminated. Deal with it properly in loggings instead of segfaulting when the user want to see the logs :-/ 2004-07-22 Martin Quinson - Fix some stupid bug preventing cbps (callback postit) from working 2004-07-21 Martin Quinson - Some documentation cleanups - remove the useless last argument of msgtype_declare - rename the Virtu functions to fit into the 'os' namespace - move headers src/include -> src/include/gras/ and stop fooling with gras -> . symbolic link - make distcheck is now successful 2004-07-19 Martin Quinson Version 0.1.1 - Build shared library also - Install html doc to the right location - stop removing maintainer files in make clean - build tests only on make check 2004-07-13 Martin Quinson version 0.1 - No major issue in previous version => change versionning schema - Re-enable little64 convertion test now that Abdou kindly regenerated the corresponding dataset. 2004-07-11 Martin Quinson version 0.0.4 - Get it working with any kind of structure (we can compute the padding bytes remotely for all the architectures I have access to) - Implement the structure parsing macro (still not quite robust/complete) - Improvement to the remote testing toysuite 2004-07-10 Martin Quinson [autoconf mechanism] - get ride of a bunch of deprecated macros - actually run the test for two-compliment, not only compile it :-/ - test whether the structures get packed (and bail out if yes. Damn. Alignment is a serious matter) - test whether the structures get compacted (but respecting the alignment constraints of each types) - test whether the array fields of structures can straddle alignment boundaries [base] - Damnit, double are bigger than float (typo in creation of 'double' datadesc) (took me 2 hours to find that bug, looking at the wrong place) - Add gras_datadesc_declare_{union,struct}_close(). They must be used before sending/receiving and are used to compute the offsets of fields - Given that padding size depend even on compiler options, keep track of alignment and aligned_size only for the current architecture. Not a big deal since we send structure fields one after the other (seems reasonable). - Add the datastructure used for IEEE paper by the PBIO guys to the test program, let it work on linux/gcc/little32. portability todo. 2004-07-08 Martin Quinson - import and improve remote compilation support from FAST - make sure make check works on half a dozen of machines out there 2004-07-07 Martin Quinson Let's say it's version 0.0.3 ;) - Implement conversions (yuhu!) - Let it work on solaris (beside conversion, of course) - Stupid me, using rand() to generate the conversion datatests in not wise. 2004-07-06 Martin Quinson - Let make dist work, since I'm gonna need it to compile on remote hosts - Let Tests/datadesc_usage write the architecture on which the file was generated as first byte. - Add PowerPC (being also IRIX64), SPARC (also power4) and ALPHA architecture descriptions. - Add datadesc_usage.{i386,ppc,sparc} files being the result of execution on those architectures. - Optimization: send/recv array of scalar in one shoot 2004-07-05 Martin Quinson - YEAH! GRAS/SG and GRAS/RL are both able to run the ping example ! - Plug a whole bunch of memleaks - each process now have to call gras_{init,exit}. One day, their log settings will be separated - Continue the code factorisation between SG, RL and common in Transport. 2004-07-04 Martin Quinson [Transport] - Redistribution between SG and RL. We wanna have to accept in SG, so move accepted related parts of RL in the common part. (more precisely, the dynar of all known sockets is no more a static in transport.c, but part of the process_data) [Core/module.c] [gras_stub_generator] - Bug fix: Do call gras_process_init from gras_init (wasnt called in RL). 2004-07-03 Martin Quinson - Create a new log channel tbx containing dict, set, log, dynar (to shut them all up in one shot) [DataDesc] - Fix the ugly case of reference to dynamic array. - New (semi-public) function gras_datadesc_size to allow the messaging layer to malloc the needed space for the buffer. [Transport] - gras_socket_close now expect the socket to close (and not its address to put NULL in it after it). This is because the socket passed to handlers is one of their argument (=> not writable). [Messaging] - propagate the interface cleanup from last week in datadesc, ie remove a superfluous level of indirection. User pass adress of variable containing data (both when sending and receiving), and not of a variable being a pointer to the data. Let's say that I like it better ;) The price for that is constructs like "int msg=*(int*)payload" in handlers, but it's a fine price, IMHO. [examples/ping] - Let it work in RL (yuhu) 2004-06-21 Martin Quinson [Transport] - porting SG plugin and SG select to new standards (works almost). - plug memleaks and fix bugs around. [DataDesc] - cleanup the prototype of data recv and force users to specify when they want to handle references to objects. Test case working even for cycles. - plug memleaks. Valgrind is perfectly ok with this. 2004-06-12 Martin Quinson [Transport] - cleanup the separation between plugin and main code in plugin creation 2004-06-11 Martin Quinson [Transport] - Reput hook for raw sockets, needed for BW experiments - kill a few lines of dead code [Data description] Interface cleanup - gras_datadesc_by_name returns the searched type or NULL. That way, no variable is needed to use a type desc once, which makes the code clearer. - gras_datadesc_declare_[struct|union]_append_name is removed. The last two parameters were strings (field name, type name), leading to common errors. [Dicos] Interface cleanup - gras_dico_retrieve -> gras_dico_get ; gras_dico_insert -> gras_dico_set This is consistant with the dynar API. 2004-04-21 Martin Quinson [Messaging] - Porting to new standards. [Data description] - interface cleanup. There is no bag anymore, no need to take extra provision to mask the pointers behind "ID". Better splitup of functions between files create/exchange/convert. This is still a bit artificial since convert and receive are so interleaved, but anyway. [Virtu(process)] - add a queued message list to procdata (the ones not matching criteria in msg_wait) - factorize some more code between SG and RL wrt procdata [Tests] - use gras_exit in example to track memleaks - get rid of gs_example now that GS is properly integrated into gras - update run_test to integrate the latest tests (datadesc) [Logging] - rename WARNINGn macros to WARNn since it prooved error-prone 2004-04-19 Martin Quinson [Data description] - register init/exit functions within gras module mechanism - send/receive function. Convertion is not implemented, but short-cutted if not needed. struct/array elements are sent one by one (instead of block-wise), but nobody really cares (yet). Get a prototype before optimizing. - tests (using a file socket) for DD send/receive on: - base types: int, float - array: fixed size, string (ie ref to dynamic string) - structure: homogeneous, heterogeneous - chained list, graph with cycle Believe it or not, valgrind is not too unhappy with the results. The cycle happily segfaults, but the others are ok. And I'm sick of pointers for now. [Transport] [File plugin] - Bugfix when using a filename explicitely (instead of '-') 2004-04-09 Martin Quinson [Transport plugins] - factorize more code between RL and SG in socket creation - Complete the implementation and tests of: o TCP o file (only in RL, and mainly for debugging) I lost 3 days to design a portable address resolver, and then decided that the prototype mainly have to run on my box. Addressing portability too early may be like optimizing too early :-/ [Tests] - use gras_init in the Tests instead of the crappy parse_log_opt (the latter function is removed) [Conditional execution] - New functions: gras_if_RL/gras_if_SG (basic support for this) [Code reorganisation] - Get rid of libgrasutils.a since it makes more trouble than it solves. Build examples against the RL library, since there is no way to disable its creation for now. For information, the beginning of coding on GRAS was back in june 2003. I guess that every line has been rewritten at least twice since then. SimGrid-3.11/README000644 001750 001750 00000001523 12342443666 012717 0ustar00cici000000 000000 Welcome to the SimGrid project! SimGrid is a scientific instrument to study the behavior of large-scale distributed systems such as Grids, Clouds, HPC or P2P systems. It can be used to evaluate heuristics, prototype applications or even assess legacy MPI applications. More documentation is included in this archive (doc/html/index.html) or online at http://simgrid.gforge.inria.fr/ In any case, you may want to subscribe to the user mailing list (http://lists.gforge.inria.fr/mailman/listinfo/simgrid-user). There, you can find answers to your questions, or simply discuss with people doing the same kind of research than you do, in an active and friendly community. Thanks for using our software. Please do great things with it and tell the world about it. Tell us, too, because we love to have positive feedback. Cheers, Da SimGrid Team. SimGrid-3.11/CMakeLists.txt000644 001750 001750 00000021345 12342443653 014577 0ustar00cici000000 000000 cmake_minimum_required(VERSION 2.6) ### Need to set rc ccompiler before enable language if(WIN32) SET(CMAKE_RC_COMPILER "windres") endif() project(SimGrid C) if (enable_gtnets OR enable_ns3 OR enable_model-checking) enable_language(CXX) endif() enable_language(CXX) if (NOT DEFINED enable_smpi OR enable_smpi) # smpi is enabled by default # Call enable_language(Fortran) in order to load the build rules for # this language, needed by teshsuite/smpi/mpich-test/. Use # CMAKE_FORCE_Fortran_COMPILER to bypass checks for a working # compiler (smpiff don't exist at configure time). include(CMakeForceCompiler) if(NOT COMMAND CMAKE_FORCE_Fortran_COMPILER) MACRO(CMAKE_FORCE_Fortran_COMPILER compiler id) SET(CMAKE_Fortran_COMPILER "${compiler}") SET(CMAKE_Fortran_COMPILER_ID_RUN TRUE) SET(CMAKE_Fortran_COMPILER_ID ${id}) SET(CMAKE_Fortran_COMPILER_WORKS TRUE) SET(CMAKE_Fortran_COMPILER_FORCED TRUE) # Set old compiler id variables. IF("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU") SET(CMAKE_COMPILER_IS_GNUG77 1) ENDIF("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU") ENDMACRO(CMAKE_FORCE_Fortran_COMPILER) endif() CMAKE_FORCE_Fortran_COMPILER(smpiff smpiff) enable_language(Fortran OPTIONAL) endif() set(CMAKE_C_FLAGS "" CACHE TYPE INTERNAL FORCE) set(CMAKE_CXX_FLAGS "" CACHE TYPE INTERNAL FORCE) set(CMAKE_EXE_LINKER_FLAGS "" CACHE TYPE INTERNAL FORCE) set(CMAKE_C_LINK_FLAGS "" CACHE TYPE INTERNAL FORCE) set(CMAKE_Fortran_FLAGS "" CACHE TYPE INTERNAL FORCE) set(CMAKE_Fortran_LINK_FLAGS "" CACHE TYPE INTERNAL FORCE) ## Mapping version number -> version name # 3.5.99 -> alpha1 (oops) # 3.5.9{1,2} -> beta{1,2} # 3.5.9{3,4,5} -> rc{1,2,3} # 3.6.{0,1,2} -> release 3.6, 3.6.1, 3.6.2 # 3.7.{0,1} -> release 3.7, 3.7.1 # 3.8.{0,1} -> release 3.8, 3.8.1 # 3.9.0 -> release 3.9 # 3.9.90 -> release 3.10pre1 # 3.10.0 -> release 3.10 # 3.11.0 -> release 3.11 set(SIMGRID_VERSION_MAJOR "3") set(SIMGRID_VERSION_MINOR "11") set(SIMGRID_VERSION_PATCH "0") #set(SIMGRID_VERSION_EXTRA "-devel") # Extra words to add to version string (e.g. -rc1) set(SIMGRID_VERSION_DATE "2014") # Year for copyright information if(${SIMGRID_VERSION_PATCH} EQUAL "0") set(release_version "${SIMGRID_VERSION_MAJOR}.${SIMGRID_VERSION_MINOR}") else() set(release_version "${SIMGRID_VERSION_MAJOR}.${SIMGRID_VERSION_MINOR}.${SIMGRID_VERSION_PATCH}") endif() set(SIMGRID_VERSION_STRING "SimGrid version ${release_version}${SIMGRID_VERSION_EXTRA}\\nCopyright (c) 2004-${SIMGRID_VERSION_DATE}. The Simgrid Team.") set(libsimgrid_version "${release_version}") set(libsimgrid-java_version "${release_version}") set(GCC_NEED_VERSION "4.0") set(APPLE_NEED_GCC_VERSION "4.6") ### SET THE LIBRARY EXTENSION AND GCC VERSION if(APPLE) #MAC set(LIB_EXE "dylib") else() if(WIN32) #WINDOWS set(LIB_EXE "a") set(BIN_EXE ".exe") else() #UNIX set(LIB_EXE "so") endif() endif() if(${CMAKE_C_COMPILER_ID} STREQUAL "GNU") exec_program("${CMAKE_C_COMPILER} --version" OUTPUT_VARIABLE "COMPILER_C_VERSION") exec_program("${CMAKE_CXX_COMPILER} --version" OUTPUT_VARIABLE "COMPILER_CXX_VERSION") string(REGEX MATCH "[0-9].[0-9].[0-9]" COMPILER_C_VERSION "${COMPILER_C_VERSION}") string(REGEX MATCH "[0-9].[0-9].[0-9]" COMPILER_CXX_VERSION "${COMPILER_CXX_VERSION}") string(REGEX MATCH "^[0-9].[0-9]" COMPILER_C_VERSION_MAJOR_MINOR "${COMPILER_C_VERSION}") string(REPLACE "${COMPILER_C_VERSION_MAJOR_MINOR}." "" COMPILER_C_VERSION_PATCH "${COMPILER_C_VERSION}") if(${GCC_NEED_VERSION} GREATER COMPILER_C_VERSION_MAJOR_MINOR) message(FATAL_ERROR "Gcc must be to version ${GCC_NEED_VERSION} current version ${COMPILER_C_VERSION_MAJOR_MINOR}") endif() endif() exec_program("${CMAKE_LINKER} --version" OUTPUT_VARIABLE "LINKER_VERSION") string(REGEX MATCH "[0-9].[0-9]*" LINKER_VERSION "${LINKER_VERSION}") string(REGEX MATCH "cl.exe" VBC "${CMAKE_C_COMPILER}") if(VBC) message(FATAL_ERROR "VB is not yet supported by Simgrid.") endif() ### Find programs and paths FIND_PROGRAM(GCOV_PATH gcov) include(FindPerl) if(NOT PERL_EXECUTABLE) message(FATAL_ERROR "-- SimGrid cannot be compiled without Perl installed -- sorry. Bailling out.") endif() ### Set some variables for Cmake SET(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib) set(INCLUDES ${CMAKE_HOME_DIRECTORY} ${CMAKE_HOME_DIRECTORY}/include ${CMAKE_HOME_DIRECTORY}/src ${CMAKE_HOME_DIRECTORY}/src/include ${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR}/include ${CMAKE_BINARY_DIR}/src ) if(WIN32) set(INCLUDES ${INCLUDES} ${CMAKE_HOME_DIRECTORY}/include/xbt ${CMAKE_HOME_DIRECTORY}/src/xbt) #for win32_ucontext.[ch] endif() set(CMAKE_SOURCE_DIR ${PROJECT_SOURCE_DIRECTORY}) if(NOT CMAKE_CROSSCOMPILING AND EXISTS /usr/include/) set(INCLUDES ${INCLUDES} /usr/include/) endif() ### Check 32bits or 64bits INCLUDE (CheckTypeSize) CHECK_TYPE_SIZE("void*" SIZEOF_VOIDSTAR) IF(SIZEOF_VOIDSTAR EQUAL 4) SET(ARCH_32_BITS 1) ELSE() SET(ARCH_32_BITS 0) ENDIF() if(WIN32) #Need env INCLUDE set(CMAKE_INCLUDE_WIN "${CMAKE_C_COMPILER}") set(CMAKE_LIB_WIN "${CMAKE_C_COMPILER}") string(REGEX REPLACE "/bin/gcc.*" "/include" CMAKE_INCLUDE_WIN "${CMAKE_INCLUDE_WIN}") string(REGEX REPLACE "/bin/gcc.*" "/lib" CMAKE_LIB_WIN "${CMAKE_LIB_WIN}") set(INCLUDES ${INCLUDES} ${CMAKE_INCLUDE_WIN}) if(CMAKE_COMPILER_IS_GNUCC) set(__GNUC__ 1) exec_program("${CMAKE_C_COMPILER} --version" OUTPUT_VARIABLE "COMPILER_C_VERSION") string(REGEX MATCH "[0-9].[0-9].[0-9]" COMPILER_C_VERSION "${COMPILER_C_VERSION}") string(REGEX MATCH "^[0-9]" COMPILER_C_MAJOR_VERSION "${COMPILER_C_VERSION}") string(REGEX MATCH "^[0-9].[0-9]" COMPILER_C_MINOR_VERSION "${COMPILER_C_VERSION}") string(REGEX REPLACE "^${COMPILER_C_MAJOR_VERSION}." "" COMPILER_C_MINOR_VERSION "${COMPILER_C_MINOR_VERSION}") if(COMPILER_C_MAJOR_VERSION) # set(__GNUC__ ${COMPILER_C_MAJOR_VERSION}) endif() if(COMPILER_C_MINOR_VERSION) # set(__GNUC_MINOR__ ${COMPILER_C_MINOR_VERSION}) endif() set(MSVC 0) set(BORLAND 0) else() message(FATAL_ERROR "Please use MinGW to compile SimGrid!") endif() if(ARCH_32_BITS) ### Arch 32bits set(_WIN32 1) else() ### Arch 64bits set(_WIN64 1) endif() set(NSIS_WIN_VERSION $ENV{PROCESSOR_ARCHITEW6432}) if(NSIS_WIN_VERSION MATCHES "") set(NSIS_WIN_VERSION $ENV{PROCESSOR_ARCHITECTURE}) endif() string(TOLOWER ${NSIS_WIN_VERSION} NSIS_WIN_VERSION) set(_XBT_WIN32 1) message(STATUS "C_COMPILER ${CMAKE_C_COMPILER} ${COMPILER_C_VERSION}") message(STATUS "CXX_COMPILER ${CMAKE_CXX_COMPILER} ${COMPILER_CXX_VERSION}") message(STATUS "CMAKE_RC_COMPILER ${CMAKE_RC_COMPILER}") message(STATUS "INCLUDE ${CMAKE_INCLUDE_WIN}") message(STATUS "LIB ${CMAKE_LIB_WIN}") message(STATUS "MAKE_PROGRAM ${CMAKE_MAKE_PROGRAM}") message(STATUS "CMAKE_BUILD_TOOL ${CMAKE_BUILD_TOOL}") message(STATUS "LINKER ${CMAKE_LINKER}") message(STATUS "CMAKE_GENERATOR ${CMAKE_GENERATOR}") message(STATUS "BORLAND ${BORLAND}") message(STATUS "VISUALC ${MSVC}") message(STATUS "GNUC ${CMAKE_COMPILER_IS_GNUCC}") endif() include_directories(${INCLUDES}) ### Setup Options include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Option.cmake) ### Make the *.h files with *.h.in files include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/CompleteInFiles.cmake) ### Define source packages for Libs include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/DefinePackages.cmake) ### Build some Maintainer files include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/MaintainerMode.cmake) include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/UnitTesting.cmake) ### Setup gcc flags include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Flags.cmake) ### Make Libs if(NOT WIN32) include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/MakeLib.cmake) else() include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/MakeLibWin.cmake) endif() ### Make Exes include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/MakeExe.cmake) ### Make tests if(enable_memcheck_xml) set(enable_memcheck true) endif() include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/AddTests.cmake) include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/CTestConfig.cmake) ### Setup the distrib include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Distrib.cmake) ### Pipol compilation include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/Pipol.cmake) ### Build the doc if(NOT WIN32) include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/GenerateDoc.cmake) else() include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/GenerateDocWin.cmake) endif() ### Print ARGS include(${CMAKE_HOME_DIRECTORY}/buildtools/Cmake/PrintArgs.cmake) INCLUDE(Dart)