src/mc/mc_comm_pattern.cpp

   1 /* Copyright (c) 2007-2015. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include <string.h>
   8
   9 #include <xbt/sysdep.h>
  10 #include <xbt/dynar.h>
  11
  12 #include "src/mc/mc_comm_pattern.h"
  13 #include "src/mc/mc_smx.h"
  14 #include "src/mc/mc_xbt.hpp"
  15
  16 using simgrid::mc::remote;
  17
  18 extern "C" {
  19
  20 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_comm_pattern, mc,
  21                                 "Logging specific to MC communication patterns");
  22
  23 mc_comm_pattern_t MC_comm_pattern_dup(mc_comm_pattern_t comm)
  24 {
  25   mc_comm_pattern_t res = xbt_new0(s_mc_comm_pattern_t, 1);
  26   res->index = comm->index;
  27   res->type = comm->type;
  28   res->comm_addr = comm->comm_addr;
  29   res->rdv = xbt_strdup(comm->rdv);
  30   res->data_size = -1;
  31   res->data = NULL;
  32   if (comm->type == SIMIX_COMM_SEND) {
  33     res->src_proc = comm->src_proc;
  34     res->src_host = comm->src_host;
  35     if (comm->data != NULL) {
  36       res->data_size = comm->data_size;
  37       res->data = xbt_malloc0(comm->data_size);
  38       memcpy(res->data, comm->data, comm->data_size);
  39     }
  40   } else {
  41     res->dst_proc = comm->dst_proc;
  42     res->dst_host = comm->dst_host;
  43   }
  44   return res;
  45 }
  46
  47 xbt_dynar_t MC_comm_patterns_dup(xbt_dynar_t patterns)
  48 {
  49   xbt_dynar_t res = xbt_dynar_new(sizeof(mc_comm_pattern_t), MC_comm_pattern_free_voidp);
  50
  51   mc_comm_pattern_t comm;
  52   unsigned int cursor;
  53   xbt_dynar_foreach(patterns, cursor, comm) {
  54     mc_comm_pattern_t copy_comm = MC_comm_pattern_dup(comm);
  55     xbt_dynar_push(res, &copy_comm);
  56   }
  57
  58   return res;
  59 }
  60
  61 static void MC_patterns_copy(xbt_dynar_t dest, xbt_dynar_t source)
  62 {
  63   xbt_dynar_reset(dest);
  64
  65   unsigned int cursor;
  66   mc_comm_pattern_t comm;
  67   xbt_dynar_foreach(source, cursor, comm) {
  68     mc_comm_pattern_t copy_comm = MC_comm_pattern_dup(comm);
  69     xbt_dynar_push(dest, &copy_comm);
  70   }
  71 }
  72
  73 void MC_restore_communications_pattern(mc_state_t state)
  74 {
  75   mc_list_comm_pattern_t list_process_comm;
  76   unsigned int cursor;
  77
  78   xbt_dynar_foreach(initial_communications_pattern, cursor, list_process_comm){
  79     list_process_comm->index_comm = (int)xbt_dynar_get_as(state->index_comm, cursor, int);
  80   }
  81
  82   for (unsigned i = 0; i < MC_smx_get_maxpid(); i++) {
  83     MC_patterns_copy(
  84       xbt_dynar_get_as(incomplete_communications_pattern, i, xbt_dynar_t),
  85       xbt_dynar_get_as(state->incomplete_comm_pattern, i, xbt_dynar_t)
  86     );
  87   }
  88 }
  89
  90 void MC_state_copy_incomplete_communications_pattern(mc_state_t state)
  91 {
  92   state->incomplete_comm_pattern = xbt_dynar_new(sizeof(xbt_dynar_t), xbt_dynar_free_voidp);
  93
  94   for (unsigned i=0; i < MC_smx_get_maxpid(); i++) {
  95     xbt_dynar_t comms = xbt_dynar_get_as(incomplete_communications_pattern, i, xbt_dynar_t);
  96     xbt_dynar_t copy = MC_comm_patterns_dup(comms);
  97     xbt_dynar_insert_at(state->incomplete_comm_pattern, i, &copy);
  98   }
  99 }
 100
 101 void MC_state_copy_index_communications_pattern(mc_state_t state)
 102 {
 103   state->index_comm = xbt_dynar_new(sizeof(unsigned int), NULL);
 104   mc_list_comm_pattern_t list_process_comm;
 105   unsigned int cursor;
 106   xbt_dynar_foreach(initial_communications_pattern, cursor, list_process_comm){
 107     xbt_dynar_push_as(state->index_comm, unsigned int, list_process_comm->index_comm);
 108   }
 109 }
 110
 111 void MC_handle_comm_pattern(
 112   e_mc_call_type_t call_type, smx_simcall_t req,
 113   int value, xbt_dynar_t pattern, int backtracking)
 114 {
 115
 116   switch(call_type) {
 117   case MC_CALL_TYPE_NONE:
 118     break;
 119   case MC_CALL_TYPE_SEND:
 120   case MC_CALL_TYPE_RECV:
 121     MC_get_comm_pattern(pattern, req, call_type, backtracking);
 122     break;
 123   case MC_CALL_TYPE_WAIT:
 124   case MC_CALL_TYPE_WAITANY:
 125     {
 126       smx_synchro_t comm_addr = NULL;
 127       if (call_type == MC_CALL_TYPE_WAIT)
 128         comm_addr = simcall_comm_wait__get__comm(req);
 129       else
 130         // comm_addr = REMOTE(xbt_dynar_get_as(simcall_comm_waitany__get__comms(req), value, smx_synchro_t)):
 131         simgrid::mc::read_element(mc_model_checker->process(), &comm_addr,
 132           remote(simcall_comm_waitany__get__comms(req)), value, sizeof(comm_addr));
 133       MC_complete_comm_pattern(pattern, comm_addr,
 134         MC_smx_simcall_get_issuer(req)->pid, backtracking);
 135     }
 136     break;
 137   default:
 138     xbt_die("Unexpected call type %i", (int)call_type);
 139   }
 140
 141 }
 142
 143 void MC_comm_pattern_free(mc_comm_pattern_t p)
 144 {
 145   xbt_free(p->rdv);
 146   xbt_free(p->data);
 147   xbt_free(p);
 148   p = NULL;
 149 }
 150
 151 static void MC_list_comm_pattern_free(mc_list_comm_pattern_t l)
 152 {
 153   xbt_dynar_free(&(l->list));
 154   xbt_free(l);
 155   l = NULL;
 156 }
 157
 158 void MC_comm_pattern_free_voidp(void *p)
 159 {
 160   MC_comm_pattern_free((mc_comm_pattern_t) * (void **) p);
 161 }
 162
 163 void MC_list_comm_pattern_free_voidp(void *p)
 164 {
 165   MC_list_comm_pattern_free((mc_list_comm_pattern_t) * (void **) p);
 166 }
 167
 168 }