{
XBT_INFO("Storage info on %s:", simgrid::s4u::Host::current()->getCname());
- for (const auto&kv : mounts) {
+ for (auto const& kv : mounts) {
std::string mountpoint = kv.first;
simgrid::s4u::Storage* storage = kv.second;
fprintf(file, " <events>\n");
for (auto const& event : this->event_set)
- event->print(file);
+ event->print(file);
fprintf(file, " </events>\n");
fprintf(file, "</jedule>\n");
return res;
}
} else {
- for(simgrid::mc::Member& member : type->members) {
+ for (simgrid::mc::Member& member : type->members) {
// TODO, optimize this? (for the offset case)
void *real_member1 = simgrid::dwarf::resolve_member(
real_area1, type, &member, (simgrid::mc::AddressSpace*) snapshot1, process_index);
return nullptr;
}
- for(simgrid::mc::Member& member : type->members) {
+ for (simgrid::mc::Member& member : type->members) {
if (member.has_offset_location()) {
// We have the offset, use it directly (shortcut):
if (member.offset() == offset)
}
case DW_TAG_structure_type:
case DW_TAG_class_type:
- for(simgrid::mc::Member& member : type->members) {
+ for (simgrid::mc::Member& member : type->members) {
void *member1 = simgrid::dwarf::resolve_member(
real_area1, type, &member, snapshot1, process_index);
void *member2 = simgrid::dwarf::resolve_member(
if (not scope || not scope->range.contain(stack_frame->ip))
return;
- for(simgrid::mc::Variable& current_variable :
- scope->variables) {
+ for (simgrid::mc::Variable& current_variable : scope->variables) {
if (not valid_variable(¤t_variable, scope, (void*)stack_frame->ip))
continue;
}
// Recursive processing of nested scopes:
- for(simgrid::mc::Frame& nested_scope : scope->scopes)
+ for (simgrid::mc::Frame& nested_scope : scope->scopes)
fill_local_variables_values(
stack_frame, &nested_scope, process_index, result);
}
}
// Zero the memory:
- for(auto const& region : mc_model_checker->process().ignored_regions())
+ for (auto const& region : mc_model_checker->process().ignored_regions())
snapshot->process()->clear_bytes(remote(region.addr), region.size);
}
static inline
void restore_snapshot_regions(simgrid::mc::Snapshot* snapshot)
{
- for(std::unique_ptr<s_mc_mem_region_t> const& region : snapshot->snapshot_regions) {
+ for (std::unique_ptr<s_mc_mem_region_t> const& region : snapshot->snapshot_regions) {
// For privatized, variables we decided it was not necessary to take the snapshot:
if (region)
restore(region.get());
// Someone needs this to be sorted but who?
boost::range::sort(info->global_variables, MC_compare_variable);
- for(simgrid::mc::Variable& variable : info->global_variables)
+ for (simgrid::mc::Variable& variable : info->global_variables)
if (variable.type_id)
variable.type = simgrid::util::find_map_ptr(
info->types, variable.type_id);
// Recursive post-processing of nested-scopes:
for (simgrid::mc::Frame& nested_scope : scope->scopes)
- mc_post_process_scope(info, &nested_scope);
-
+ mc_post_process_scope(info, &nested_scope);
}
static
static void MC_post_process_types(simgrid::mc::ObjectInformation* info)
{
// Lookup "subtype" field:
- for(auto& i : info->types) {
+ for (auto& i : info->types) {
i.second.subtype = MC_resolve_type(info, i.second.type_id);
for (simgrid::mc::Member& member : i.second.members)
member.type = MC_resolve_type(info, member.type_id);
total_time += elapsed_time;
/* let's see which tasks are done */
- for (const auto& model : *all_existing_models) {
+ for (auto const& model : *all_existing_models) {
surf_action_t action = surf_model_extract_done_action_set(model);
while (action != nullptr) {
SD_task_t task = static_cast<SD_task_t>(action->getData());
sd_global->return_set->insert(task);
/* remove the dependencies after this task */
- for (const auto& succ : *task->successors) {
+ for (auto const& succ : *task->successors) {
succ->predecessors->erase(task);
succ->inputs->erase(task);
XBT_DEBUG("Release dependency on %s: %zu remain(s). Becomes schedulable if %zu=0", SD_task_get_name(succ),
}
task->successors->clear();
- for (const auto& output : *task->outputs) {
+ for (auto const& output : *task->outputs) {
output->start_time = task->finish_time;
output->predecessors->erase(task);
if (SD_task_get_state(output) == SD_SCHEDULED)
if (not sd_global->watch_point_reached && how_long < 0 && not sd_global->initial_tasks->empty()) {
XBT_WARN("Simulation is finished but %zu tasks are still not done", sd_global->initial_tasks->size());
- for (const auto& t : *sd_global->initial_tasks)
+ for (auto const& t : *sd_global->initial_tasks)
XBT_WARN("%s is in %s state", SD_task_get_name(t), __get_state_name(SD_task_get_state(t)));
}
void SD_simulate_with_update(double how_long, xbt_dynar_t changed_tasks_dynar)
{
std::set<SD_task_t> *changed_tasks = simgrid::sd::simulate(how_long);
- for (const auto& task : *changed_tasks)
+ for (auto const& task : *changed_tasks)
xbt_dynar_push(changed_tasks_dynar, &task);
}
/* If only daemon processes remain, cancel their actions, mark them to die and reschedule them */
if (simix_global->process_list.size() == simix_global->daemons.size())
- for (const auto& dmon : simix_global->daemons) {
+ for (auto const& dmon : simix_global->daemons) {
XBT_DEBUG("Kill %s", dmon->cname());
SIMIX_process_kill(dmon, simix_global->maestro_process);
}
std::vector<std::pair<size_t, size_t>> shift_and_frame_private_blocks(const std::vector<std::pair<size_t, size_t>> vec, size_t offset, size_t buff_size) {
std::vector<std::pair<size_t, size_t>> result;
for (auto const& block : vec) {
- auto new_block = std::make_pair(std::min(std::max((size_t)0, block.first-offset), buff_size),
- std::min(std::max((size_t)0, block.second-offset), buff_size));
- if(new_block.second > 0 && new_block.first < buff_size)
- result.push_back(new_block);
+ auto new_block = std::make_pair(std::min(std::max((size_t)0, block.first - offset), buff_size),
+ std::min(std::max((size_t)0, block.second - offset), buff_size));
+ if (new_block.second > 0 && new_block.first < buff_size)
+ result.push_back(new_block);
}
return result;
}
}
MPI_Request* requests = xbt_new(MPI_Request, rankmap.size());
int reqs = 0;
- for (const auto& rank : rankmap) {
+ for (auto const& rank : rankmap) {
if (rank.second != 0) {
group_snd[reqs]=new Group(group_out);
requests[reqs] = Request::isend(&(group_snd[reqs]), 1, MPI_PTR, rank.second, system_tag, this);
smpi_bw_factor = parse_factor(xbt_cfg_get_string("smpi/bw-factor"));
double current = 1.0;
- for (const auto& fact : smpi_bw_factor) {
+ for (auto const& fact : smpi_bw_factor) {
if (size <= fact.factor) {
XBT_DEBUG("%f <= %zu return %f", size, fact.factor, current);
return current;
smpi_lat_factor = parse_factor(xbt_cfg_get_string("smpi/lat-factor"));
double current = 1.0;
- for (const auto& fact : smpi_lat_factor) {
+ for (auto const& fact : smpi_lat_factor) {
if (size <= fact.factor) {
XBT_DEBUG("%f <= %zu return %f", size, fact.factor, current);
return current;
XBT_DEBUG ("Set every models in the right state by updating them to 0.");
for (auto const& model : *all_existing_models)
- model->updateActionsState(NOW, 0.0);
+ model->updateActionsState(NOW, 0.0);
}
double surf_solve(double max_date)