comm_pattern->dst_proc = dst_proc->get_pid();
comm_pattern->src_host = MC_smx_actor_get_host_name(src_proc);
comm_pattern->dst_host = MC_smx_actor_get_host_name(dst_proc);
- if (comm_pattern->data.size() == 0 && comm->src_buff_ != nullptr) {
+ if (comm_pattern->data.empty() && comm->src_buff_ != nullptr) {
size_t buff_size;
mc_model_checker->get_remote_simulation().read(&buff_size, remote(comm->dst_buff_size_));
comm_pattern->data.resize(buff_size);
if (diff != NONE_DIFF) {
if (comm->type == PatternCommunicationType::send) {
- this->send_deterministic = 0;
+ this->send_deterministic = false;
if (this->send_diff != nullptr)
xbt_free(this->send_diff);
this->send_diff = print_determinism_result(diff, process, comm, list.index_comm + 1);
} else {
- this->recv_deterministic = 0;
+ this->recv_deterministic = false;
if (this->recv_diff != nullptr)
xbt_free(this->recv_diff);
this->recv_diff = print_determinism_result(diff, process, comm, list.index_comm + 1);
const mc::PatternCommunicationList& initial_pattern = initial_communications_pattern[issuer->get_pid()];
const std::vector<PatternCommunication*>& incomplete_pattern = incomplete_communications_pattern[issuer->get_pid()];
- std::unique_ptr<PatternCommunication> pattern(new PatternCommunication());
+ auto pattern = std::make_unique<PatternCommunication>();
pattern->index = initial_pattern.index_comm + incomplete_pattern.size();
if (call_type == MC_CALL_TYPE_SEND) {
initial_communications_pattern.resize(maxpid);
incomplete_communications_pattern.resize(maxpid);
- std::unique_ptr<State> initial_state(new State(++expanded_states_count_));
+ ++expanded_states_count_;
+ auto initial_state = std::make_unique<State>(expanded_states_count_);
XBT_DEBUG("********* Start communication determinism verification *********");
mc_model_checker->wait_for_requests();
/* Create the new expanded state */
- std::unique_ptr<State> next_state(new State(++expanded_states_count_));
+ ++expanded_states_count_;
+ auto next_state = std::make_unique<State>(expanded_states_count_);
/* If comm determinism verification, we cannot stop the exploration if some communications are not finished (at
* least, data are transferred). These communications are incomplete and they cannot be analyzed and compared