"far: %.2E, average load as reported by the HostLoad plugin: %.5f (should be %.5f)",
simgrid::s4u::Engine::get_clock() - start, host->get_speed(), speed, sg_host_get_computed_flops(host),
sg_host_get_avg_load(host),
- static_cast<double>(200E6) /
- (10.5 * speed * host->get_core_count() +
- (simgrid::s4u::Engine::get_clock() - start - 0.5) * host->get_speed() * host->get_core_count()));
+ 200E6 / (10.5 * speed * host->get_core_count() +
+ (simgrid::s4u::Engine::get_clock() - start - 0.5) * host->get_speed() * host->get_core_count()));
// ========= Change power peak =========
int pstate = 1;
}
msg_error_t status;
- status = MSG_comm_wait(comm,static_cast<double>(timeout));
+ status = MSG_comm_wait(comm, timeout);
env->SetBooleanField(jcomm, jcomm_field_Comm_finished, JNI_TRUE);
if (status == MSG_OK) {
jcomm_bind_task(env,jcomm);
if (not comms)
return;
- MSG_comm_waitall(comms, count, static_cast<double>(timeout));
+ MSG_comm_waitall(comms, count, timeout);
delete[] comms;
}
JNIEXPORT int JNICALL Java_org_simgrid_msg_Comm_waitAny(JNIEnv *env, jclass cls, jobjectArray jcomms)
if (jname)
name = env->GetStringUTFChars(jname, 0);
- msg_task_t task = MSG_task_create(name, static_cast<double>(jflopsAmount), static_cast<double>(jbytesAmount), jtask);
+ msg_task_t task = MSG_task_create(name, jflopsAmount, jbytesAmount, jtask);
if (jname)
env->ReleaseStringUTFChars(jname, name);
jobjectArray jhosts, jdoubleArray jcomputeDurations_arg,
jdoubleArray jmessageSizes_arg)
{
- int host_count = static_cast<int>(env->GetArrayLength(jhosts));
+ int host_count = env->GetArrayLength(jhosts);
jdouble* jcomputeDurations = env->GetDoubleArrayElements(jcomputeDurations_arg, 0);
msg_host_t* hosts = new msg_host_t[host_count];
jxbt_throw_notbound(env, "task", jtask);
return;
}
- MSG_task_set_priority(task, static_cast<double>(priority));
+ MSG_task_set_priority(task, priority);
}
JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_setFlopsAmount (JNIEnv *env, jobject jtask, jdouble computationAmount)
jxbt_throw_notbound(env, "task", jtask);
return;
}
- MSG_task_set_flops_amount(task, static_cast<double>(computationAmount));
+ MSG_task_set_flops_amount(task, computationAmount);
}
JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_setBytesAmount (JNIEnv *env, jobject jtask, jdouble dataSize)
return;
}
env->SetDoubleField(jtask, jtask_field_Task_messageSize, dataSize);
- MSG_task_set_bytes_amount(task, static_cast<double>(dataSize));
+ MSG_task_set_bytes_amount(task, dataSize);
}
JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_sendBounded(JNIEnv * env,jobject jtask, jstring jalias,
MSG_task_set_data(task, (void *) env->NewGlobalRef(jtask));
const char* alias = env->GetStringUTFChars(jalias, 0);
- msg_error_t res =
- MSG_task_send_with_timeout_bounded(task, alias, static_cast<double>(jtimeout), static_cast<double>(maxrate));
+ msg_error_t res = MSG_task_send_with_timeout_bounded(task, alias, jtimeout, maxrate);
env->ReleaseStringUTFChars(jalias, alias);
if (res != MSG_OK)
msg_task_t task = nullptr;
const char *alias = env->GetStringUTFChars(jalias, 0);
- msg_error_t res = MSG_task_receive_ext_bounded(&task, alias, static_cast<double>(jtimeout), /*host*/ nullptr,
- static_cast<double>(rate));
+ msg_error_t res = MSG_task_receive_ext_bounded(&task, alias, jtimeout, /*host*/ nullptr, rate);
if (env->ExceptionOccurred())
return nullptr;
if (res != MSG_OK) {
}
const char* mailbox = env->GetStringUTFChars(jmailbox, 0);
- msg_comm_t comm = MSG_task_irecv_bounded(task, mailbox, static_cast<double>(rate));
+ msg_comm_t comm = MSG_task_irecv_bounded(task, mailbox, rate);
env->ReleaseStringUTFChars(jmailbox, mailbox);
env->SetLongField(jcomm, jtask_field_Comm_bind, (jlong) (uintptr_t)(comm));
/* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
MSG_task_set_data(task, (void *) env->NewGlobalRef(jtask));
- MSG_task_dsend_bounded(task, alias, msg_task_cancel_on_failed_dsend,static_cast<double>(maxrate));
+ MSG_task_dsend_bounded(task, alias, msg_task_cancel_on_failed_dsend, maxrate);
env->ReleaseStringUTFChars(jalias, alias);
}
{
double computed_flops = sg_host_get_computed_flops(get_host()) - comp_counter;
double target_time = (simgrid::s4u::Engine::get_clock() - start_time);
- target_time =
- target_time *
- static_cast<double>(99.0 / 100.0); // FIXME We account for t_copy arbitrarily with 1% -- this needs to be fixed
+ target_time = target_time * 99.0 / 100.0; // FIXME We account for t_copy arbitrarily with 1%
+ // -- this needs to be fixed
bool is_initialized = rates[task_id][best_pstate] != 0;
rates[task_id][best_pstate] = computed_flops / comp_timer;
* (maxCpuLoad is by definition 1)
*/
int coreCount = host_->get_core_count();
- double coreReciprocal = static_cast<double>(1) / static_cast<double>(coreCount);
+ double coreReciprocal = 1.0 / coreCount;
if (coreCount > 1)
power_slope = (max_power - min_power) / (1 - coreReciprocal);
else
double HostLoad::get_current_load()
{
// We don't need to call update() here because it is called every time an action terminates or starts
- return current_flops_ / static_cast<double>(host_->get_speed() * host_->get_core_count());
+ return current_flops_ / (host_->get_speed() * host_->get_core_count());
}
/*
PASS_ZEROCOUNT(count)
smpi_bench_end();
int rank_traced = simgrid::s4u::this_actor::get_pid();
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read", static_cast<double>(count*datatype->size())));
+ TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read", count * datatype->size()));
int ret = simgrid::smpi::File::read(fh, buf, count, datatype, status);
TRACE_smpi_comm_out(rank_traced);
smpi_bench_begin();
PASS_ZEROCOUNT(count)
smpi_bench_end();
int rank_traced = simgrid::s4u::this_actor::get_pid();
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read_shared", static_cast<double>(count*datatype->size())));
+ TRACE_smpi_comm_in(rank_traced, __func__,
+ new simgrid::instr::CpuTIData("IO - read_shared", count * datatype->size()));
int ret = simgrid::smpi::File::read_shared(fh, buf, count, datatype, status);
TRACE_smpi_comm_out(rank_traced);
smpi_bench_begin();
PASS_ZEROCOUNT(count)
smpi_bench_end();
int rank_traced = simgrid::s4u::this_actor::get_pid();
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write", static_cast<double>(count*datatype->size())));
+ TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write", count * datatype->size()));
int ret = simgrid::smpi::File::write(fh, const_cast<void*>(buf), count, datatype, status);
TRACE_smpi_comm_out(rank_traced);
smpi_bench_begin();
PASS_ZEROCOUNT(count)
smpi_bench_end();
int rank_traced = simgrid::s4u::this_actor::get_pid();
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write_shared", static_cast<double>(count*datatype->size())));
+ TRACE_smpi_comm_in(rank_traced, __func__,
+ new simgrid::instr::CpuTIData("IO - write_shared", count * datatype->size()));
int ret = simgrid::smpi::File::write_shared(fh, buf, count, datatype, status);
TRACE_smpi_comm_out(rank_traced);
smpi_bench_begin();
CHECK_FLAGS(fh)
smpi_bench_end();
int rank_traced = simgrid::s4u::this_actor::get_pid();
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read_all", static_cast<double>(count*datatype->size())));
+ TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read_all", count * datatype->size()));
int ret = fh->op_all<simgrid::smpi::File::read>(buf, count, datatype, status);
TRACE_smpi_comm_out(rank_traced);
smpi_bench_begin();
CHECK_FLAGS(fh)
smpi_bench_end();
int rank_traced = simgrid::s4u::this_actor::get_pid();
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read_ordered", static_cast<double>(count*datatype->size())));
+ TRACE_smpi_comm_in(rank_traced, __func__,
+ new simgrid::instr::CpuTIData("IO - read_ordered", count * datatype->size()));
int ret = simgrid::smpi::File::read_ordered(fh, buf, count, datatype, status);
TRACE_smpi_comm_out(rank_traced);
smpi_bench_begin();
CHECK_RDONLY(fh)
smpi_bench_end();
int rank_traced = simgrid::s4u::this_actor::get_pid();
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write_all", static_cast<double>(count*datatype->size())));
+ TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write_all", count * datatype->size()));
int ret = fh->op_all<simgrid::smpi::File::write>(const_cast<void*>(buf), count, datatype, status);
TRACE_smpi_comm_out(rank_traced);
smpi_bench_begin();
CHECK_RDONLY(fh)
smpi_bench_end();
int rank_traced = simgrid::s4u::this_actor::get_pid();
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write_ordered", static_cast<double>(count*datatype->size())));
+ TRACE_smpi_comm_in(rank_traced, __func__,
+ new simgrid::instr::CpuTIData("IO - write_ordered", count * datatype->size()));
int ret = simgrid::smpi::File::write_ordered(fh, buf, count, datatype, status);
TRACE_smpi_comm_out(rank_traced);
smpi_bench_begin();
PASS_ZEROCOUNT(count);
smpi_bench_end();
int rank_traced = simgrid::s4u::this_actor::get_pid();
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read", static_cast<double>(count*datatype->size())));
+ TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read", count * datatype->size()));
int ret = fh->seek(offset,MPI_SEEK_SET);
if(ret!=MPI_SUCCESS)
return ret;
CHECK_FLAGS(fh)
smpi_bench_end();
int rank_traced = simgrid::s4u::this_actor::get_pid();
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - read_at_all", static_cast<double>(count*datatype->size())));
+ TRACE_smpi_comm_in(rank_traced, __func__,
+ new simgrid::instr::CpuTIData("IO - read_at_all", count * datatype->size()));
int ret = fh->seek(offset,MPI_SEEK_SET);
if(ret!=MPI_SUCCESS)
return ret;
PASS_ZEROCOUNT(count);
smpi_bench_end();
int rank_traced = simgrid::s4u::this_actor::get_pid();
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write", static_cast<double>(count*datatype->size())));
+ TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write", count * datatype->size()));
int ret = fh->seek(offset,MPI_SEEK_SET);
if(ret!=MPI_SUCCESS)
return ret;
CHECK_RDONLY(fh)
smpi_bench_end();
int rank_traced = simgrid::s4u::this_actor::get_pid();
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("IO - write_at_all", static_cast<double>(count*datatype->size())));
+ TRACE_smpi_comm_in(rank_traced, __func__,
+ new simgrid::instr::CpuTIData("IO - write_at_all", count * datatype->size()));
int ret = fh->seek(offset,MPI_SEEK_SET);
if(ret!=MPI_SUCCESS)
return ret;
}
int rank_traced = simgrid::s4u::this_actor::get_pid(); // FIXME: In PMPI_Wait, we check if the comm is null?
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("waitAny", static_cast<double>(count)));
+ TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("waitAny", count));
*index = simgrid::smpi::Request::waitany(count, requests, status);
}
int rank_traced = simgrid::s4u::this_actor::get_pid(); // FIXME: In PMPI_Wait, we check if the comm is null?
- TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("waitall", static_cast<double>(count)));
+ TRACE_smpi_comm_in(rank_traced, __func__, new simgrid::instr::CpuTIData("waitall", count));
int retval = simgrid::smpi::Request::waitall(count, requests, status);
{
if (not smpi_process())
return sleep(secs);
- return private_sleep(static_cast<double>(secs));
+ return private_sleep(secs);
}
int smpi_usleep(useconds_t usecs)
{
if (not smpi_process())
return usleep(usecs);
- return static_cast<int>(private_sleep(static_cast<double>(usecs) / 1000000.0));
+ return static_cast<int>(private_sleep(usecs / 1000000.0));
}
#if _POSIX_TIMERS > 0
{
if (not smpi_process())
return nanosleep(tp,t);
- return static_cast<int>(private_sleep(static_cast<double>(tp->tv_sec + tp->tv_nsec / 1000000000.0)));
+ return static_cast<int>(private_sleep(tp->tv_sec + tp->tv_nsec / 1000000000.0));
}
#endif
double period = xbt_os_timer_elapsed(smpi_process()->timer());
data.sum += period;
data.sum_pow2 += period * period;
- double n = static_cast<double>(data.count);
+ double n = data.count;
data.mean = data.sum / n;
data.relstderr = sqrt((data.sum_pow2 / n - data.mean * data.mean) / n) / data.mean;
void NetworkIBModel::computeIBfactors(IBNode* root)
{
- double num_comm_out = static_cast<double>(root->ActiveCommsUp.size());
+ double num_comm_out = root->ActiveCommsUp.size();
double max_penalty_out = 0.0;
// first, compute all outbound penalties to get their max
for (std::vector<ActiveComm*>::iterator it = root->ActiveCommsUp.begin(); it != root->ActiveCommsUp.end(); ++it) {
XBT_INFO("%s sends %llu to %s", simgrid::s4u::this_actor::get_cname(), read_size, remote_host.c_str());
std::string* payload = new std::string(simgrid::xbt::string_printf("%s %llu", dest.c_str(), read_size));
simgrid::s4u::Mailbox* mailbox = simgrid::s4u::Mailbox::by_name(remote_host);
- mailbox->put(payload, static_cast<double>(read_size));
+ mailbox->put(payload, read_size);
simgrid::s4u::this_actor::sleep_for(.4);
}