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 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_comm_pattern, mc,
  19                                 "Logging specific to MC communication patterns");
  20
  21 extern "C" {
  22
  23 mc_comm_pattern_t MC_comm_pattern_dup(mc_comm_pattern_t comm)
  24 {
  25   mc_comm_pattern_t res = new s_mc_comm_pattern_t();
  26   res->index = comm->index;
  27   res->type = comm->type;
  28   res->comm_addr = comm->comm_addr;
  29   res->rdv = comm->rdv;
  30   res->data = comm->data;
  31   res->dst_proc = comm->dst_proc;
  32   res->dst_host = comm->dst_host;
  33   return res;
  34 }
  35
  36 xbt_dynar_t MC_comm_patterns_dup(xbt_dynar_t patterns)
  37 {
  38   xbt_dynar_t res = xbt_dynar_new(sizeof(mc_comm_pattern_t), MC_comm_pattern_free_voidp);
  39
  40   mc_comm_pattern_t comm;
  41   unsigned int cursor;
  42   xbt_dynar_foreach(patterns, cursor, comm) {
  43     mc_comm_pattern_t copy_comm = MC_comm_pattern_dup(comm);
  44     xbt_dynar_push(res, &copy_comm);
  45   }
  46
  47   return res;
  48 }
  49
  50 static void MC_patterns_copy(xbt_dynar_t dest, xbt_dynar_t source)
  51 {
  52   xbt_dynar_reset(dest);
  53
  54   unsigned int cursor;
  55   mc_comm_pattern_t comm;
  56   xbt_dynar_foreach(source, cursor, comm) {
  57     mc_comm_pattern_t copy_comm = MC_comm_pattern_dup(comm);
  58     xbt_dynar_push(dest, &copy_comm);
  59   }
  60 }
  61
  62 void MC_restore_communications_pattern(simgrid::mc::State* state)
  63 {
  64   mc_list_comm_pattern_t list_process_comm;
  65   unsigned int cursor;
  66
  67   xbt_dynar_foreach(initial_communications_pattern, cursor, list_process_comm)
  68     list_process_comm->index_comm = state->communicationIndices[cursor];
  69
  70   for (unsigned i = 0; i < MC_smx_get_maxpid(); i++)
  71     MC_patterns_copy(
  72       xbt_dynar_get_as(incomplete_communications_pattern, i, xbt_dynar_t),
  73       xbt_dynar_get_as(state->incomplete_comm_pattern, i, xbt_dynar_t)
  74     );
  75 }
  76
  77 void MC_state_copy_incomplete_communications_pattern(simgrid::mc::State* state)
  78 {
  79   state->incomplete_comm_pattern = xbt_dynar_new(sizeof(xbt_dynar_t), xbt_dynar_free_voidp);
  80
  81   for (unsigned i=0; i < MC_smx_get_maxpid(); i++) {
  82     xbt_dynar_t comms = xbt_dynar_get_as(incomplete_communications_pattern, i, xbt_dynar_t);
  83     xbt_dynar_t copy = MC_comm_patterns_dup(comms);
  84     xbt_dynar_insert_at(state->incomplete_comm_pattern, i, &copy);
  85   }
  86 }
  87
  88 void MC_state_copy_index_communications_pattern(simgrid::mc::State* state)
  89 {
  90   state->communicationIndices.clear();
  91   mc_list_comm_pattern_t list_process_comm;
  92   unsigned int cursor;
  93   xbt_dynar_foreach(initial_communications_pattern, cursor, list_process_comm)
  94     state->communicationIndices.push_back(list_process_comm->index_comm);
  95 }
  96
  97 void MC_handle_comm_pattern(
  98   e_mc_call_type_t call_type, smx_simcall_t req,
  99   int value, xbt_dynar_t pattern, int backtracking)
 100 {
 101
 102   switch(call_type) {
 103   case MC_CALL_TYPE_NONE:
 104     break;
 105   case MC_CALL_TYPE_SEND:
 106   case MC_CALL_TYPE_RECV:
 107     MC_get_comm_pattern(pattern, req, call_type, backtracking);
 108     break;
 109   case MC_CALL_TYPE_WAIT:
 110   case MC_CALL_TYPE_WAITANY:
 111     {
 112       smx_synchro_t comm_addr = nullptr;
 113       if (call_type == MC_CALL_TYPE_WAIT)
 114         comm_addr = simcall_comm_wait__get__comm(req);
 115       else
 116         // comm_addr = REMOTE(xbt_dynar_get_as(simcall_comm_waitany__get__comms(req), value, smx_synchro_t)):
 117         simgrid::mc::read_element(mc_model_checker->process(), &comm_addr,
 118           remote(simcall_comm_waitany__get__comms(req)), value, sizeof(comm_addr));
 119       MC_complete_comm_pattern(pattern, comm_addr,
 120         MC_smx_simcall_get_issuer(req)->pid, backtracking);
 121     }
 122     break;
 123   default:
 124     xbt_die("Unexpected call type %i", (int)call_type);
 125   }
 126
 127 }
 128
 129 void MC_comm_pattern_free(mc_comm_pattern_t p)
 130 {
 131   delete p;
 132   p = nullptr;
 133 }
 134
 135 static void MC_list_comm_pattern_free(mc_list_comm_pattern_t l)
 136 {
 137   xbt_dynar_free(&(l->list));
 138   xbt_free(l);
 139   l = nullptr;
 140 }
 141
 142 void MC_comm_pattern_free_voidp(void *p)
 143 {
 144   MC_comm_pattern_free((mc_comm_pattern_t) * (void **) p);
 145 }
 146
 147 void MC_list_comm_pattern_free_voidp(void *p)
 148 {
 149   MC_list_comm_pattern_free((mc_list_comm_pattern_t) * (void **) p);
 150 }
 151
 152 }