void smpi_get_executable_global_size()
{
char buffer[PATH_MAX];
char* full_name = realpath(xbt_binary_name, buffer);
if (full_name == nullptr)
xbt_die("Could not resolve binary file name");
std::vector<simgrid::xbt::VmMap> map = simgrid::xbt::get_memory_map(getpid());
for (auto i = map.begin(); i != map.end() ; ++i) {
// TODO, In practice, this implementation would not detect a completely
// anonymous data segment. This does not happen in practice, however.
// File backed RW entry:
if (i->pathname == full_name && (i->prot & PROT_RWX) == PROT_RW) {
smpi_start_data_exe = (char*) i->start_addr;
smpi_size_data_exe = i->end_addr - i->start_addr;
++i;
/* Here we are making the assumption that a suitable empty region
following the rw- area is the end of the data segment. It would
be better to check with the size of the data segment. */
if (i != map.end() && i->pathname.empty() && (i->prot & PROT_RWX) == PROT_RW
&& i->start_addr == (std::uint64_t) smpi_start_data_exe + smpi_size_data_exe) {
smpi_size_data_exe = i->end_addr - (std::uint64_t) smpi_start_data_exe;
}
return;
}
}
xbt_die("Did not find my data segment.");
}
/** Terrorist. This process sends a bunch of exceptions to the victim. */
static int terrorist(int argc, char *argv[])
{
msg_process_t victim_process = NULL;
XBT_INFO("Let's create a victim.");
victim_process = MSG_process_create("victim", victim, NULL, MSG_host_self());
XBT_INFO("Going to sleep for 1 second");
if (MSG_process_sleep(1) != MSG_OK)
xbt_die("What's going on??? I failed to sleep!");
XBT_INFO("Send a first exception (host failure)");
SIMIX_process_throw(victim_process, host_error, 0, "First Trick: Let's pretend that the host failed");
XBT_INFO("Sweet, let's prepare a second trick!");
XBT_INFO("Going to sleep for 2 seconds");
if (MSG_process_sleep(2) != MSG_OK)
xbt_die("What's going on??? I failed to sleep!");
XBT_INFO("Send a second exception (host failure)");
SIMIX_process_throw(victim_process, host_error, 0, "Second Trick: Let's pretend again that the host failed");
XBT_INFO("Sweet, let's prepare a third trick!");
XBT_INFO("Going to sleep for 3 seconds");
if (MSG_process_sleep(3) != MSG_OK)
xbt_die("What's going on??? I failed to sleep!");
XBT_INFO("Send a third exception (cancellation)");
SIMIX_process_throw(victim_process, cancel_error, 0, "Third Trick: Let's pretend this time that someone canceled something");
XBT_INFO("OK, goodbye now.");
return 0;
}
static void* shm_map(int fd, size_t size, shared_data_t* data) {
void* mem;
char loc[PTR_STRLEN];
shared_metadata_t* meta;
if(size > shm_size(fd)) {
if(ftruncate(fd, (off_t)size) < 0) {
xbt_die("Could not truncate fd %d to %zu: %s", fd, size, strerror(errno));
}
}
mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if(mem == MAP_FAILED) {
xbt_die("Could not map fd %d: %s", fd, strerror(errno));
}
if(!allocs_metadata) {
allocs_metadata = xbt_dict_new();
}
snprintf(loc, PTR_STRLEN, "%p", mem);
meta = xbt_new(shared_metadata_t, 1);
meta->size = size;
meta->data = data;
xbt_dict_set(allocs_metadata, loc, meta, &free);
XBT_DEBUG("MMAP %zu to %p", size, mem);
return mem;
}
/** @brief Find the snapshoted region from a pointer
*
* @param addr Pointer
* @param snapshot Snapshot
* @param Snapshot region in the snapshot this pointer belongs to
* (or NULL if it does not belong to any snapshot region)
* */
mc_mem_region_t mc_get_snapshot_region(
const void* addr, const simgrid::mc::Snapshot* snapshot, int process_index)
{
size_t n = snapshot->snapshot_regions.size();
for (size_t i = 0; i != n; ++i) {
mc_mem_region_t region = snapshot->snapshot_regions[i].get();
if (!(region && region->contain(simgrid::mc::remote(addr))))
continue;
if (region->storage_type() == simgrid::mc::StorageType::Privatized) {
#ifdef HAVE_SMPI
// Use the current process index of the snapshot:
if (process_index == simgrid::mc::ProcessIndexDisabled) {
process_index = snapshot->privatization_index;
}
if (process_index < 0) {
xbt_die("Missing process index");
}
if (process_index >= (int) region->privatized_data().size()) {
xbt_die("Invalid process index");
}
simgrid::mc::RegionSnapshot& priv_region = region->privatized_data()[process_index];
xbt_assert(priv_region.contain(simgrid::mc::remote(addr)));
return &priv_region;
#else
xbt_die("Privatized region in a non SMPI build (this should not happen)");
#endif
}
return region;
}
return NULL;
}
static void smx_ctx_cojava_create_coroutine(smx_ctx_cojava_t context) {
JNIEnv *env = get_current_thread_env();
jclass coclass = (*env)->FindClass(env, "java/dyn/Coroutine");
xbt_assert((coclass != NULL), "Can't find coroutine class ! :(");
jobject jcoroutine = (*env)->NewObject(env, coclass, coroutine_init, context->jprocess);
if (jcoroutine == NULL) {
FILE *conf= fopen("/proc/sys/vm/max_map_count","r");
if (conf) {
int limit=-1;
if(fscanf(conf,"%d",&limit) != 1)
xbt_die("Error while creating a new coroutine. Parse error.");
fclose(conf);
if (limit!=-1 && SIMIX_process_count() > (limit - 100) /2)
xbt_die("Error while creating a new coroutine. "
"This seem due to the the vm.max_map_count system limit that is only equal to %d while we already have %d coroutines. "
"Please check the install documentation to see how to increase this limit", limit, SIMIX_process_count());
if (limit == -1)
xbt_die("Error while creating a new coroutine. "
"This seems to be a non-linux system, disabling the automatic verification that the system limit on the amount of memory maps is high enough.");
xbt_die("Error while creating a new coroutine. ");
}
}
jcoroutine = (*env)->NewGlobalRef(env, jcoroutine);
context->jcoroutine = jcoroutine;
}
/** Victim. This process gets a lot of remote exceptions */
static int victim(int argc, char *argv[]) {
xbt_ex_t e;
msg_error_t res = MSG_OK;
XBT_INFO("Let's work.");
TRY {
res = MSG_task_execute(MSG_task_create("Task", 1e14, 0, NULL));
if (res != MSG_OK) {
XBT_INFO("The MSG_task_execute caught the exception for me and returned %d)",res);
} else {
xbt_die("I was expecting an exception during my execution!");
}
} CATCH(e) {
XBT_INFO("The received exception resumed my execution. Good. Here is it: ----------------------->8----");
xbt_ex_display(&e);
XBT_INFO("(end of the first exception) ----8<------------------------");
xbt_ex_free(e);
}
XBT_INFO("Let's get suspended.");
int gotit = 0;
TRY {
MSG_process_suspend(MSG_process_self());
} CATCH(e) {
XBT_INFO("The received exception resumed my suspension. Good. Here is it: ----------------------->8----");
xbt_ex_display(&e);
XBT_INFO("(end of the second exception) ----8<------------------------");
gotit = 1;
xbt_ex_free(e);
}
if(!gotit) {
xbt_die("I was expecting an exception during my suspension!");
}
XBT_INFO("Let's sleep for 10 seconds.");
TRY {
res = MSG_process_sleep(10);
if (res != MSG_OK) {
XBT_INFO("The MSG_process_sleep caught the exception for me and returned %d)",res);
} else {
xbt_die("I was expecting to get an exception during my nap.");
}
} CATCH(e) {
XBT_INFO("Got the second exception: ----------------------->8----");
xbt_ex_display(&e);
XBT_INFO("(end of the third exception) ----8<------------------------");
xbt_ex_free(e);
}
XBT_INFO("Let's try a last time to do something on something");
MSG_process_sleep(10);
XBT_INFO("That's enough now. I quit.");
return 0;
}
int main(int argc, char** argv)
{
// We need to keep the original parameters in order to pass them to the
// model-checked process:
int argc_copy = argc;
char** argv_copy = argvdup(argc, argv);
xbt_log_init(&argc_copy, argv_copy);
sg_config_init(&argc_copy, argv_copy);
if (argc < 2)
xbt_die("Missing arguments.\n");
bool server_mode = true;
char* env = std::getenv("SIMGRID_MC_MODE");
if (env) {
if (std::strcmp(env, "server") == 0)
server_mode = true;
else if (std::strcmp(env, "standalone") == 0)
server_mode = false;
else
xbt_die("Unrecognised value for SIMGRID_MC_MODE (server/standalone)");
}
if (!server_mode) {
setenv(MC_ENV_VARIABLE, "1", 1);
execvp(argv[1], argv+1);
std::perror("simgrid-mc");
return 127;
}
// Create a AF_LOCAL socketpair:
int res;
int sockets[2];
res = socketpair(AF_LOCAL, SOCK_DGRAM | SOCK_CLOEXEC, 0, sockets);
if (res == -1) {
perror("simgrid-mc");
return MC_SERVER_ERROR;
}
XBT_DEBUG("Created socketpair");
pid_t pid = fork();
if (pid < 0) {
perror("simgrid-mc");
return MC_SERVER_ERROR;
} else if (pid == 0) {
close(sockets[1]);
return do_child(sockets[0], argv);
} else {
close(sockets[0]);
return do_parent(sockets[1], pid);
}
return 0;
}
/** \brief Initialize the location of a member of a type
* (DW_AT_data_member_location of a DW_TAG_member).
*
* \param type a type (struct, class)
* \param member the member of the type
* \param child DIE of the member (DW_TAG_member)
*/
static void MC_dwarf_fill_member_location(
simgrid::mc::Type* type, simgrid::mc::Member* member, Dwarf_Die * child)
{
if (dwarf_hasattr(child, DW_AT_data_bit_offset))
xbt_die("Can't groke DW_AT_data_bit_offset.");
if (not dwarf_hasattr_integrate(child, DW_AT_data_member_location)) {
if (type->type == DW_TAG_union_type)
return;
xbt_die
("Missing DW_AT_data_member_location field in DW_TAG_member %s of type <%"
PRIx64 ">%s", member->name.c_str(),
(uint64_t) type->id, type->name.c_str());
}
Dwarf_Attribute attr;
dwarf_attr_integrate(child, DW_AT_data_member_location, &attr);
int form = dwarf_whatform(&attr);
simgrid::dwarf::FormClass form_class = simgrid::dwarf::classify_form(form);
switch (form_class) {
case simgrid::dwarf::FormClass::ExprLoc:
case simgrid::dwarf::FormClass::Block:
// Location expression:
{
Dwarf_Op *expr;
size_t len;
if (dwarf_getlocation(&attr, &expr, &len))
xbt_die
("Could not read location expression DW_AT_data_member_location in DW_TAG_member %s of type <%"
PRIx64 ">%s", MC_dwarf_attr_integrate_string(child, DW_AT_name),
(uint64_t) type->id, type->name.c_str());
member->location_expression = simgrid::dwarf::DwarfExpression(expr, expr+len);
break;
}
case simgrid::dwarf::FormClass::Constant:
// Offset from the base address of the object:
{
Dwarf_Word offset;
if (not dwarf_formudata(&attr, &offset))
member->offset(offset);
else
xbt_die("Cannot get %s location <%" PRIx64 ">%s",
MC_dwarf_attr_integrate_string(child, DW_AT_name),
(uint64_t) type->id, type->name.c_str());
break;
}
default:
// includes FormClass::LocListPtr (reference to a location list: TODO) and FormClass::Reference (it's supposed to be
// possible in DWARF2 but I couldn't find its semantic in the spec)
xbt_die("Can't handle form class (%d) / form 0x%x as DW_AT_member_location", (int)form_class, (unsigned)form);
}
}
void read_element(AddressSpace const& as,
void* local, remote_ptr<s_xbt_dynar_t> addr, size_t i, size_t len)
{
s_xbt_dynar_t d;
as.read_bytes(&d, sizeof(d), addr);
if (i >= d.used)
xbt_die("Out of bound index %zi/%lu", i, d.used);
if (len != d.elmsize)
xbt_die("Bad size in simgrid::mc::read_element");
as.read_bytes(local, len, remote(xbt_dynar_get_ptr(&d, i)));
}
static char *remplace(char *value, const char **src_list, int src_size,
const char **dst_list, int dst_size)
{
char result[BUFFER_SIZE];
int i_res = 0;
int i = 0;
while (value[i]) {
if (value[i] == '$') {
i++; /* skip the '$' */
if (value[i] < '0' || value[i] > '9')
xbt_die("bad string parameter, no number indication, at offset: "
"%d (\"%s\")", i, value);
/* solve the number */
int number = value[i++] - '0';
while (value[i] >= '0' && value[i] <= '9')
number = 10 * number + (value[i++] - '0');
/* solve the indication */
const char **param_list;
_XBT_GNUC_UNUSED int param_size;
if (value[i] == 's' && value[i + 1] == 'r' && value[i + 2] == 'c') {
param_list = src_list;
param_size = src_size;
} else if (value[i] == 'd' && value[i + 1] == 's'
&& value[i + 2] == 't') {
param_list = dst_list;
param_size = dst_size;
} else {
xbt_die("bad string parameter, support only \"src\" and \"dst\", "
"at offset: %d (\"%s\")", i, value);
}
i += 3;
xbt_assert(number < param_size,
"bad string parameter, not enough length param_size, "
"at offset: %d (\"%s\") %d %d", i, value, param_size, number);
const char *param = param_list[number];
int j = 0;
while (param[j] && i_res < BUFFER_SIZE)
result[i_res++] = param[j++];
} else {
result[i_res++] = value[i++]; /* next char */
}
if (i_res >= BUFFER_SIZE)
xbt_die("solving string \"%s\", small buffer size (%d)",
value, BUFFER_SIZE);
}
result[i_res++] = '\0';
char *res = xbt_malloc(i_res);
return memcpy(res, result, i_res);
}
tmgr_trace_t tmgr_trace_new_from_string(const char *id, const char *input,
double periodicity)
{
tmgr_trace_t trace = NULL;
int linecount = 0;
s_tmgr_event_t event;
tmgr_event_t last_event = NULL;
xbt_dynar_t list;
unsigned int cpt;
char *val;
if (trace_list) {
trace = xbt_dict_get_or_null(trace_list, id);
if (trace) {
XBT_WARN("Ignoring redefinition of trace %s", id);
return trace;
}
}
xbt_assert(periodicity >= 0,
"Invalid periodicity %lg (must be positive)", periodicity);
trace = xbt_new0(s_tmgr_trace_t, 1);
trace->type = e_trace_list;
trace->s_list.event_list = xbt_dynar_new(sizeof(s_tmgr_event_t), NULL);
list = xbt_str_split(input, "\n\r");
xbt_dynar_foreach(list, cpt, val) {
linecount++;
xbt_str_trim(val, " \t\n\r\x0B");
if (val[0] == '#' || val[0] == '\0' || val[0] == '%')
continue;
if (sscanf(val, "PERIODICITY " "%lg" "\n", &periodicity) == 1)
continue;
if (sscanf(val, "%lg" " " "%lg" "\n", &event.delta, &event.value) != 2)
xbt_die("%s:%d: Syntax error in trace\n%s", id, linecount, input);
if (last_event) {
if (last_event->delta > event.delta) {
xbt_die("%s:%d: Invalid trace: Events must be sorted, "
"but time %lg > time %lg.\n%s",
id, linecount, last_event->delta, event.delta, input);
}
last_event->delta = event.delta - last_event->delta;
}
xbt_dynar_push(trace->s_list.event_list, &event);
last_event =
xbt_dynar_get_ptr(trace->s_list.event_list,
xbt_dynar_length(trace->s_list.event_list) - 1);
}
void Client::declareSymbol(const char *name, int* value)
{
s_mc_register_symbol_message_t message;
message.type = MC_MESSAGE_REGISTER_SYMBOL;
if (strlen(name) + 1 > sizeof(message.name))
xbt_die("Symbol is too long");
strncpy(message.name, name, sizeof(message.name));
message.callback = nullptr;
message.data = value;
if (channel_.send(message))
xbt_die("Could send REGISTER_SYMBOL message to model-checker");
}
static int worker(int argc, char *argv[])
{
msg_task_t task = NULL;
char mailbox[80];
long id= xbt_str_parse_int(argv[1], "Invalid argument %s");
snprintf(mailbox, 79,"worker-%ld", id);
while (1) {
double time1 = MSG_get_clock();
int retcode = MSG_task_receive( &(task), mailbox);
double time2 = MSG_get_clock();
if (retcode == MSG_OK) {
XBT_INFO("Received \"%s\"", MSG_task_get_name(task));
if (MSG_task_get_data(task) == FINALIZE) {
MSG_task_destroy(task);
task = NULL;
break;
}
if (time1 < *((double *) task->data))
time1 = *((double *) task->data);
XBT_INFO("Communication time : \"%f\"", time2 - time1);
XBT_INFO("Processing \"%s\"", MSG_task_get_name(task));
retcode = MSG_task_execute(task);
if (retcode == MSG_OK) {
XBT_INFO("\"%s\" done", MSG_task_get_name(task));
MSG_task_destroy(task);
task = NULL;
} else if (retcode == MSG_HOST_FAILURE) {
XBT_INFO("Gloups. The cpu on which I'm running just turned off!. See you!");
MSG_task_destroy(task);
task = NULL;
return 0;
} else {
XBT_INFO("Hey ?! What's up ? ");
xbt_die("Unexpected behavior");
}
} else if (retcode == MSG_HOST_FAILURE) {
XBT_INFO("Gloups. The cpu on which I'm running just turned off!. See you!");
return 0;
} else if (retcode == MSG_TRANSFER_FAILURE) {
XBT_INFO("Mmh. Something went wrong. Nevermind. Let's keep going!");
} else {
xbt_die("Unexpected behavior");
}
}
XBT_INFO("I'm done. See you!");
return 0;
}
int slave(int argc, char *argv[])
{
while (1) {
msg_task_t task = NULL;
int a;
double time1, time2;
time1 = MSG_get_clock();
a = MSG_task_receive( &(task), MSG_host_get_name(MSG_host_self()) );
time2 = MSG_get_clock();
if (a == MSG_OK) {
XBT_INFO("Received \"%s\"", MSG_task_get_name(task));
if (MSG_task_get_data(task) == FINALIZE) {
MSG_task_destroy(task);
break;
}
if (time1 < *((double *) task->data))
time1 = *((double *) task->data);
XBT_INFO("Communication time : \"%f\"", time2 - time1);
XBT_INFO("Processing \"%s\"", MSG_task_get_name(task));
a = MSG_task_execute(task);
if (a == MSG_OK) {
XBT_INFO("\"%s\" done", MSG_task_get_name(task));
free(task->data);
MSG_task_destroy(task);
} else if (a == MSG_HOST_FAILURE) {
XBT_INFO
("Gloups. The cpu on which I'm running just turned off!. See you!");
return 0;
} else {
XBT_INFO("Hey ?! What's up ? ");
xbt_die("Unexpected behavior");
}
} else if (a == MSG_HOST_FAILURE) {
XBT_INFO
("Gloups. The cpu on which I'm running just turned off!. See you!");
return 0;
} else if (a == MSG_TRANSFER_FAILURE) {
XBT_INFO("Mmh. Something went wrong. Nevermind. Let's keep going!");
} else if (a == MSG_TIMEOUT) {
XBT_INFO("Mmh. Got a timeout. Nevermind. Let's keep going!");
} else {
XBT_INFO("Hey ?! What's up ? ");
xbt_die("Unexpected behavior");
}
}
XBT_INFO("I'm done. See you!");
return 0;
} /* end_of_slave */
void _mc_cfg_cb_reduce(const char *name)
{
if (_sg_cfg_init_status && !_sg_do_model_check)
xbt_die
("You are specifying a reduction strategy after the initialization (through MSG_config?), but model-checking was not activated at config time (through bu the program was not runned under the model-checker (with simgrid-mc)). This won't work, sorry.");
char *val = xbt_cfg_get_string(name);
if (!strcasecmp(val, "none"))
simgrid::mc::reduction_mode = simgrid::mc::ReductionMode::none;
else if (!strcasecmp(val, "dpor"))
simgrid::mc::reduction_mode = simgrid::mc::ReductionMode::dpor;
else
xbt_die("configuration option %s can only take 'none' or 'dpor' as a value",
name);
}
/** Receiver function */
int receiver(int argc, char *argv[])
{
double time, time1, sender_time;
msg_task_t task_la = NULL;
msg_task_t task_bw = NULL;
int a;
double communication_time = 0;
XBT_INFO("receiver");
time = MSG_get_clock();
/* Get Latency */
a = MSG_task_receive(&task_la,MSG_host_get_name(MSG_host_self()));
if (a == MSG_OK) {
time1 = MSG_get_clock();
sender_time = *((double *) (task_la->data));
time = sender_time;
communication_time = time1 - time;
XBT_INFO("Task received : %s", task_la->name);
xbt_free(task_la->data);
MSG_task_destroy(task_la);
XBT_INFO("Communic. time %le", communication_time);
XBT_INFO("--- la %f ----", communication_time);
} else {
xbt_die("Unexpected behavior");
}
/* Get Bandwidth */
a = MSG_task_receive(&task_bw,MSG_host_get_name(MSG_host_self()));
if (a == MSG_OK) {
time1 = MSG_get_clock();
sender_time = *((double *) (task_bw->data));
time = sender_time;
communication_time = time1 - time;
XBT_INFO("Task received : %s", task_bw->name);
xbt_free(task_bw->data);
MSG_task_destroy(task_bw);
XBT_INFO("Communic. time %le", communication_time);
XBT_INFO("--- bw %f ----", task_comm_size_bw / communication_time);
} else {
xbt_die("Unexpected behavior");
}
return 0;
} /* end_of_receiver */
CpuCas01Model::CpuCas01Model() : simgrid::surf::CpuModel()
{
char *optim = xbt_cfg_get_string("cpu/optim");
bool select = xbt_cfg_get_boolean("cpu/maxmin-selective-update");
if (!strcmp(optim, "Full")) {
updateMechanism_ = UM_FULL;
selectiveUpdate_ = select;
} else if (!strcmp(optim, "Lazy")) {
updateMechanism_ = UM_LAZY;
selectiveUpdate_ = true;
xbt_assert(select || (xbt_cfg_is_default_value("cpu/maxmin-selective-update")),
"Disabling selective update while using the lazy update mechanism is dumb!");
} else {
xbt_die("Unsupported optimization (%s) for this model", optim);
}
p_cpuRunningActionSetThatDoesNotNeedBeingChecked = new ActionList();
maxminSystem_ = lmm_system_new(selectiveUpdate_);
if (getUpdateMechanism() == UM_LAZY) {
actionHeap_ = xbt_heap_new(8, nullptr);
xbt_heap_set_update_callback(actionHeap_, surf_action_lmm_update_index_heap);
modifiedSet_ = new ActionLmmList();
maxminSystem_->keep_track = modifiedSet_;
}
}
xbt_dynar_foreach(dax, cursor, task) {
int kind = SD_task_get_kind(task);
SD_workstation_t *wsl = SD_task_get_workstation_list(task);
switch (kind) {
case SD_TASK_COMP_SEQ:
fprintf(out, "[%f] %s compute %f # %s\n",
SD_task_get_start_time(task),
SD_workstation_get_name(wsl[0]), SD_task_get_amount(task),
SD_task_get_name(task));
break;
case SD_TASK_COMM_E2E:
fprintf(out, "[%f] %s send %s %f # %s\n",
SD_task_get_start_time(task),
SD_workstation_get_name(wsl[0]),
SD_workstation_get_name(wsl[1]), SD_task_get_amount(task),
SD_task_get_name(task));
fprintf(out, "[%f] %s recv %s %f # %s\n",
SD_task_get_finish_time(task),
SD_workstation_get_name(wsl[1]),
SD_workstation_get_name(wsl[0]), SD_task_get_amount(task),
SD_task_get_name(task));
break;
default:
xbt_die("Task %s is of unknown kind %d", SD_task_get_name(task),
SD_task_get_kind(task));
}
SD_task_destroy(task);
}
/** @brief Read memory from a snapshot region broken across fragmented pages
*
* @param addr Process (non-snapshot) address of the data
* @param region Snapshot memory region where the data is located
* @param target Buffer to store the value
* @param size Size of the data to read in bytes
* @return Pointer where the data is located (target buffer of original location)
*/
const void* MC_region_read_fragmented(mc_mem_region_t region, void* target, const void* addr, size_t size)
{
// Last byte of the memory area:
void* end = (char*) addr + size - 1;
// Page of the last byte of the memory area:
size_t page_end = mc_page_number(NULL, end);
void* dest = target;
if (dest==NULL) {
xbt_die("Missing destination buffer for fragmented memory access");
}
// Read each page:
while (mc_page_number(NULL, addr) != page_end) {
void* snapshot_addr = mc_translate_address_region_chunked((uintptr_t) addr, region);
void* next_page = mc_page_from_number(NULL, mc_page_number(NULL, addr) + 1);
size_t readable = (char*) next_page - (char*) addr;
memcpy(dest, snapshot_addr, readable);
addr = (char*) addr + readable;
dest = (char*) dest + readable;
size -= readable;
}
// Read the end:
void* snapshot_addr = mc_translate_address_region_chunked((uintptr_t)addr, region);
memcpy(dest, snapshot_addr, size);
return target;
}
/** @brief Add an "host" to the current AS */
void sg_platf_new_host(sg_platf_host_cbarg_t host)
{
xbt_assert(! sg_host_by_name(host->id),
"Refusing to create a second host named '%s'.", host->id);
simgrid::surf::AsImpl* current_routing = routing_get_current();
if (current_routing->hierarchy_ == simgrid::surf::AsImpl::RoutingMode::unset)
current_routing->hierarchy_ = simgrid::surf::AsImpl::RoutingMode::base;
simgrid::surf::NetCard *netcard =
new simgrid::surf::NetCardImpl(host->id, SURF_NETWORK_ELEMENT_HOST, current_routing);
netcard->setId(current_routing->addComponent(netcard));
sg_host_t h = simgrid::s4u::Host::by_name_or_create(host->id);
h->pimpl_netcard = netcard;
simgrid::surf::netcardCreatedCallbacks(netcard);
if(mount_list){
xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);
mount_list = NULL;
}
if (host->coord && strcmp(host->coord, "")) {
unsigned int cursor;
char*str;
if (!COORD_HOST_LEVEL)
xbt_die ("To use host coordinates, please add --cfg=network/coordinates:yes to your command line");
/* Pre-parse the host coordinates -- FIXME factorize with routers by overloading the routing->parse_PU function*/
xbt_dynar_t ctn_str = xbt_str_split_str(host->coord, " ");
xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
xbt_dynar_foreach(ctn_str,cursor, str) {
double val = xbt_str_parse_double(str, "Invalid coordinate: %s");
xbt_dynar_push(ctn,&val);
}
/**
* \brief Add a "host_link" to the network element list
*/
static void parse_S_host_link(sg_platf_host_link_cbarg_t host)
{
sg_routing_edge_t info = NULL;
info = xbt_lib_get_or_null(host_lib, host->id, ROUTING_HOST_LEVEL);
xbt_assert(info, "Host '%s' not found!",host->id);
xbt_assert(current_routing->model_desc == &routing_models[SURF_MODEL_CLUSTER] ||
current_routing->model_desc == &routing_models[SURF_MODEL_VIVALDI],
"You have to be in model Cluster to use tag host_link!");
s_surf_parsing_link_up_down_t link_up_down;
link_up_down.link_up = xbt_lib_get_or_null(link_lib, host->link_up, SURF_LINK_LEVEL);
link_up_down.link_down = xbt_lib_get_or_null(link_lib, host->link_down, SURF_LINK_LEVEL);
link_up_down.limiter_link = NULL;
link_up_down.loopback_link = NULL;
xbt_assert(link_up_down.link_up, "Link '%s' not found!",host->link_up);
xbt_assert(link_up_down.link_down, "Link '%s' not found!",host->link_down);
if(!current_routing->link_up_down_list)
current_routing->link_up_down_list = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);
// If dynar is is greater than edge id and if the host_link is already defined
if(xbt_dynar_length(current_routing->link_up_down_list) > info->id &&
xbt_dynar_get_as(current_routing->link_up_down_list,info->id,void*))
xbt_die("Host_link for '%s' is already defined!",host->id);
XBT_DEBUG("Push Host_link for host '%s' to position %d",info->name,info->id);
xbt_dynar_set_as(current_routing->link_up_down_list,info->id,s_surf_parsing_link_up_down_t,link_up_down);
}
/** \ingroup m_host_management
* \brief Return the number of MSG tasks currently running on a
* #msg_host_t. The external load is not taken in account.
*/
int MSG_get_host_msgload(msg_host_t h)
{
xbt_assert((h != NULL), "Invalid parameters");
xbt_die( "Not implemented yet");
return (0);
}
void MC_ignore_heap(void *address, size_t size)
{
if (mc_mode != MC_MODE_CLIENT)
return;
xbt_mheap_t heap = mmalloc_get_current_heap();
s_mc_heap_ignore_region_t region;
memset(®ion, 0, sizeof(region));
region.address = address;
region.size = size;
region.block =
((char *) address -
(char *) heap->heapbase) / BLOCKSIZE + 1;
if (heap->heapinfo[region.block].type == 0) {
region.fragment = -1;
heap->heapinfo[region.block].busy_block.ignore++;
} else {
region.fragment =
((uintptr_t) (ADDR2UINT(address) % (BLOCKSIZE))) >>
heap->heapinfo[region.block].type;
heap->heapinfo[region.block].busy_frag.ignore[region.fragment]++;
}
s_mc_ignore_heap_message_t message;
message.type = MC_MESSAGE_IGNORE_HEAP;
message.region = region;
if (MC_protocol_send(mc_client->fd, &message, sizeof(message)))
xbt_die("Could not send ignored region to MCer");
}
/** Receiver function */
int slave(int argc, char *argv[])
{
XBT_INFO("I'm a slave");
while (1) {
msg_task_t task = NULL;
int a;
a = MSG_task_receive(&(task), MSG_host_get_name(MSG_host_self()));
if (a == MSG_OK) {
XBT_INFO("Received \"%s\" ", MSG_task_get_name(task));
if (MSG_task_get_data(task) == FINALIZE) {
MSG_task_destroy(task);
break;
}
XBT_INFO("Processing \"%s\" ", MSG_task_get_name(task));
MSG_task_execute(task);
XBT_INFO("\"%s\" done ", MSG_task_get_name(task));
MSG_task_destroy(task);
} else {
XBT_INFO("Hey ?! What's up ? ");
xbt_die("Unexpected behavior");
}
}
XBT_INFO("I'm done. See you!");
return 0;
} /* end_of_slave */
/*
* Helping functions
*/
void surf_parse_error(const char *fmt, ...) {
va_list va;
va_start(va,fmt);
char *msg = bvprintf(fmt,va);
va_end(va);
xbt_die("Parse error at %s:%d: %s", surf_parsed_filename, surf_parse_lineno, msg);
}
/** @brief Find the default lower bound for a given language
*
* The default lower bound of an array (when DW_TAG_lower_bound
* is missing) depends on the language of the compilation unit.
*
* @param lang Language of the compilation unit (values defined in the DWARF spec)
* @return Default lower bound of an array in this compilation unit
* */
static uint64_t MC_dwarf_default_lower_bound(int lang)
{
switch (lang) {
case DW_LANG_C:
case DW_LANG_C89:
case DW_LANG_C99:
case DW_LANG_C_plus_plus:
case DW_LANG_D:
case DW_LANG_Java:
case DW_LANG_ObjC:
case DW_LANG_ObjC_plus_plus:
case DW_LANG_Python:
case DW_LANG_UPC:
return 0;
case DW_LANG_Ada83:
case DW_LANG_Ada95:
case DW_LANG_Fortran77:
case DW_LANG_Fortran90:
case DW_LANG_Fortran95:
case DW_LANG_Modula2:
case DW_LANG_Pascal83:
case DW_LANG_PL1:
case DW_LANG_Cobol74:
case DW_LANG_Cobol85:
return 1;
default:
xbt_die("No default DW_TAG_lower_bound for language %i and none given",
lang);
return 0;
}
}
/**
* \brief Add a "host" to the network element list
*/
static void parse_S_host(sg_platf_host_cbarg_t host)
{
if (current_routing->p_hierarchy == SURF_ROUTING_NULL)
current_routing->p_hierarchy = SURF_ROUTING_BASE;
xbt_assert(!sg_host_by_name(host->id),
"Reading a host, processing unit \"%s\" already exists", host->id);
RoutingEdge *info = new RoutingEdgeImpl(xbt_strdup(host->id),
-1,
SURF_NETWORK_ELEMENT_HOST,
current_routing);
info->setId(current_routing->parsePU(info));
sg_host_edge_set(sg_host_by_name_or_create(host->id), info);
XBT_DEBUG("Having set name '%s' id '%d'", host->id, info->getId());
if(mount_list){
xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);
mount_list = NULL;
}
if (host->coord && strcmp(host->coord, "")) {
unsigned int cursor;
char*str;
if (!COORD_HOST_LEVEL)
xbt_die ("To use host coordinates, please add --cfg=network/coordinates:yes to your command line");
/* Pre-parse the host coordinates -- FIXME factorize with routers by overloading the routing->parse_PU function*/
xbt_dynar_t ctn_str = xbt_str_split_str(host->coord, " ");
xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
xbt_dynar_foreach(ctn_str,cursor, str) {
double val = atof(str);
xbt_dynar_push(ctn,&val);
}
void SIMIX_io_finish(smx_activity_t synchro)
{
for (smx_simcall_t const& simcall : synchro->simcalls_) {
switch (synchro->state_) {
case SIMIX_DONE:
/* do nothing, synchro done */
break;
case SIMIX_FAILED:
SMX_EXCEPTION(simcall->issuer, io_error, 0, "IO failed");
break;
case SIMIX_CANCELED:
SMX_EXCEPTION(simcall->issuer, cancel_error, 0, "Canceled");
break;
default:
xbt_die("Internal error in SIMIX_io_finish: unexpected synchro state %d", static_cast<int>(synchro->state_));
}
if (simcall->issuer->host->is_off()) {
simcall->issuer->context->iwannadie = 1;
}
simcall->issuer->waiting_synchro = nullptr;
SIMIX_simcall_answer(simcall);
}
/* We no longer need it */
SIMIX_io_destroy(synchro);
}
void Client::declareStack(void *stack, size_t size, smx_actor_t process, ucontext_t* context)
{
xbt_mheap_t heap = mmalloc_get_current_heap();
s_stack_region_t region;
memset(®ion, 0, sizeof(region));
region.address = stack;
region.context = context;
region.size = size;
region.block =
((char *) stack -
(char *) heap->heapbase) / BLOCKSIZE + 1;
#if HAVE_SMPI
if (smpi_privatize_global_variables && process)
region.process_index = smpi_process_index_of_smx_process(process);
else
#endif
region.process_index = -1;
s_mc_stack_region_message_t message;
message.type = MC_MESSAGE_STACK_REGION;
message.stack_region = region;
if (channel_.send(message))
xbt_die("Coule not send STACK_REGION to model-checker");
}
Host *Host::current(){
smx_process_t smx_proc = SIMIX_process_self();
if (smx_proc == NULL)
xbt_die("Cannot call Host::current() from the maestro context");
return Host::byName(SIMIX_host_get_name(SIMIX_process_get_host(smx_proc)));
}
