// Iterate over all the sections that were specified and find the right
// value. (fact.factor represents the interval sizes; we want to find the
// section that has fact.factor <= size and no other such fact.factor <= size)
- // Note: parse_factor() (used before) already sorts the dynar we iterate over!
+ // Note: parse_factor() (used before) already sorts the vector we iterate over!
for (auto& fact : smpi_os_values) {
if (size <= fact.factor) { // Values already too large, use the previously
// computed value of current!
double current=smpi_ois_values.empty()?0.0:smpi_ois_values[0].values[0]+smpi_ois_values[0].values[1]*size;
// Iterate over all the sections that were specified and find the right value. (fact.factor represents the interval
// sizes; we want to find the section that has fact.factor <= size and no other such fact.factor <= size)
- // Note: parse_factor() (used before) already sorts the dynar we iterate over!
+ // Note: parse_factor() (used before) already sorts the vector we iterate over!
for (auto& fact : smpi_ois_values) {
if (size <= fact.factor) { // Values already too large, use the previously computed value of current!
XBT_DEBUG("ois : %zu <= %zu return %.10f", size, fact.factor, current);
// Iterate over all the sections that were specified and find the right value. (fact.factor represents the interval
// sizes; we want to find the section that has fact.factor <= size and no other such fact.factor <= size)
- // Note: parse_factor() (used before) already sorts the dynar we iterate over!
+ // Note: parse_factor() (used before) already sorts the vector we iterate over!
for (auto fact : smpi_or_values) {
- if (size <= fact.factor) { // Values already too large, use the previously
- // computed value of current!
+ if (size <= fact.factor) { // Values already too large, use the previously computed value of current!
XBT_DEBUG("or : %zu <= %zu return %.10f", size, fact.factor, current);
return current;
} else {
double smpi_mpi_wtime(){
double time;
- if (smpi_process_initialized() != 0 &&
- smpi_process_finalized() == 0 &&
- smpi_process_get_sampling() == 0) {
+ if (smpi_process_initialized() != 0 && smpi_process_finalized() == 0 && smpi_process_get_sampling() == 0) {
smpi_bench_end();
time = SIMIX_get_clock();
// to avoid deadlocks if used as a break condition, such as
MPI_Status stat;
MPI_Status *pstat = status == MPI_STATUSES_IGNORE ? MPI_STATUS_IGNORE : &stat;
int flag=1;
- int i;
- for(i=0; i<count; i++){
+ for(int i=0; i<count; i++){
if (requests[i] != MPI_REQUEST_NULL && !(requests[i]->flags & PREPARED)) {
if (smpi_mpi_test(&requests[i], pstat)!=1){
flag=0;
void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)
{
int system_tag = COLL_TAG_SCATTER;
- int rank, size, dst, index;
- MPI_Aint lb = 0, sendext = 0;
+ int dst;
+ MPI_Aint lb = 0;
+ MPI_Aint sendext = 0;
MPI_Request *requests;
- rank = smpi_comm_rank(comm);
- size = smpi_comm_size(comm);
+ int rank = smpi_comm_rank(comm);
+ int size = smpi_comm_size(comm);
if(rank != root) {
// Recv buffer from root
smpi_mpi_recv(recvbuf, recvcount, recvtype, root, system_tag, comm, MPI_STATUS_IGNORE);
}
// Send buffers to receivers
requests = xbt_new(MPI_Request, size - 1);
- index = 0;
+ int index = 0;
for(dst = 0; dst < size; dst++) {
if(dst != root) {
requests[index] = smpi_isend_init(static_cast<char *>(sendbuf) + dst * sendcount * sendext, sendcount, sendtype, dst,
MPI_Datatype recvtype, int root, MPI_Comm comm)
{
int system_tag = COLL_TAG_SCATTERV;
- int rank, size, dst, index;
- MPI_Aint lb = 0, sendext = 0;
+ int dst;
+ MPI_Aint lb = 0;
+ MPI_Aint sendext = 0;
MPI_Request *requests;
- rank = smpi_comm_rank(comm);
- size = smpi_comm_size(comm);
+ int rank = smpi_comm_rank(comm);
+ int size = smpi_comm_size(comm);
if(rank != root) {
// Recv buffer from root
smpi_mpi_recv(recvbuf, recvcount, recvtype, root, system_tag, comm, MPI_STATUS_IGNORE);
}
// Send buffers to receivers
requests = xbt_new(MPI_Request, size - 1);
- index = 0;
+ int index = 0;
for(dst = 0; dst < size; dst++) {
if(dst != root) {
requests[index] = smpi_isend_init(static_cast<char *>(sendbuf) + displs[dst] * sendext, sendcounts[dst],
MPI_Comm comm)
{
int system_tag = COLL_TAG_REDUCE;
- int rank, size, src, index;
- MPI_Aint lb = 0, dataext = 0;
+ int src, index;
+ MPI_Aint lb = 0;
+ MPI_Aint dataext = 0;
MPI_Request *requests;
void **tmpbufs;
char* sendtmpbuf = static_cast<char *>(sendbuf);
-
- rank = smpi_comm_rank(comm);
- size = smpi_comm_size(comm);
+ int rank = smpi_comm_rank(comm);
+ int size = smpi_comm_size(comm);
//non commutative case, use a working algo from openmpi
if(!smpi_op_is_commute(op)){
smpi_coll_tuned_reduce_ompi_basic_linear(sendtmpbuf, recvbuf, count, datatype, op, root, comm);
void smpi_mpi_scan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
{
int system_tag = -888;
- int rank, size, other, index;
+ int other, index;
MPI_Aint lb = 0, dataext = 0;
MPI_Request *requests;
void **tmpbufs;
- rank = smpi_comm_rank(comm);
- size = smpi_comm_size(comm);
+ int rank = smpi_comm_rank(comm);
+ int size = smpi_comm_size(comm);
smpi_datatype_extent(datatype, &lb, &dataext);
void smpi_mpi_exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
{
int system_tag = -888;
- int rank, size, other, index;
+ int other, index;
MPI_Aint lb = 0, dataext = 0;
MPI_Request *requests;
void **tmpbufs;
int recvbuf_is_empty=1;
- rank = smpi_comm_rank(comm);
- size = smpi_comm_size(comm);
+ int rank = smpi_comm_rank(comm);
+ int size = smpi_comm_size(comm);
smpi_datatype_extent(datatype, &lb, &dataext);
index = 0;
for(other = 0; other < rank; other++) {
tmpbufs[index] = smpi_get_tmp_sendbuffer(count * dataext);
- requests[index] =
- smpi_irecv_init(tmpbufs[index], count, datatype, other, system_tag, comm);
+ requests[index] = smpi_irecv_init(tmpbufs[index], count, datatype, other, system_tag, comm);
index++;
}
for(other = rank + 1; other < size; other++) {
- requests[index] =
- smpi_isend_init(sendbuf, count, datatype, other, system_tag, comm);
+ requests[index] = smpi_isend_init(sendbuf, count, datatype, other, system_tag, comm);
index++;
}
// Wait for completion of all comms.
if(recvbuf_is_empty){
smpi_datatype_copy(tmpbufs[index], count, datatype, recvbuf, count, datatype);
recvbuf_is_empty=0;
- }else
- // #Request is below rank: it's a irecv
- smpi_op_apply(op, tmpbufs[index], recvbuf, &count, &datatype);
+ } else
+ // #Request is below rank: it's a irecv
+ smpi_op_apply(op, tmpbufs[index], recvbuf, &count, &datatype);
}
}
}else{
if(recvbuf_is_empty){
smpi_datatype_copy(tmpbufs[other], count, datatype, recvbuf, count, datatype);
recvbuf_is_empty=0;
- }else smpi_op_apply(op, tmpbufs[other], recvbuf, &count, &datatype);
+ } else
+ smpi_op_apply(op, tmpbufs[other], recvbuf, &count, &datatype);
}
}
}
extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
- //unknow size from the receiver pov
+ //unknown size from the receiver point of view
if(size<=0.0){
- smpi_mpi_probe(from, 0, MPI_COMM_WORLD, &status);
- size=status.count;
+ smpi_mpi_probe(from, 0, MPI_COMM_WORLD, &status);
+ size=status.count;
}
smpi_mpi_recv(nullptr, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD, &status);
TRACE_smpi_recv(rank_traced, req->src, req->dst);
}
TRACE_smpi_ptp_out(rank_traced, -1, -1, __FUNCTION__);
- set_reqq_self(new std::vector<MPI_Request>);
}
log_timed_action (action, clock);
}
int comm_size = smpi_comm_size(MPI_COMM_WORLD);
CHECK_ACTION_PARAMS(action, 2*comm_size+2, 2)
- int send_buf_size=0,recv_buf_size=0,i=0;
int *sendcounts = xbt_new0(int, comm_size);
int *recvcounts = xbt_new0(int, comm_size);
int *senddisps = xbt_new0(int, comm_size);
MPI_Datatype MPI_CURRENT_TYPE2;
- send_buf_size=parse_double(action[2]);
- recv_buf_size=parse_double(action[3+comm_size]);
+ int send_buf_size=parse_double(action[2]);
+ int recv_buf_size=parse_double(action[3+comm_size]);
if(action[4+2*comm_size] && action[5+2*comm_size]) {
MPI_CURRENT_TYPE=decode_datatype(action[4+2*comm_size]);
MPI_CURRENT_TYPE2=decode_datatype(action[5+2*comm_size]);
void *sendbuf = smpi_get_tmp_sendbuffer(send_buf_size* smpi_datatype_size(MPI_CURRENT_TYPE));
void *recvbuf = smpi_get_tmp_recvbuffer(recv_buf_size* smpi_datatype_size(MPI_CURRENT_TYPE2));
- for(i=0;i<comm_size;i++) {
+ for(int i=0;i<comm_size;i++) {
sendcounts[i] = atoi(action[i+3]);
recvcounts[i] = atoi(action[i+4+comm_size]);
}
extra->sendcounts= xbt_new(int, comm_size);
extra->num_processes = comm_size;
- for(i=0; i< comm_size; i++){//copy data to avoid bad free
+ for(int i=0; i< comm_size; i++){//copy data to avoid bad free
extra->send_size += sendcounts[i];
extra->sendcounts[i] = sendcounts[i];
extra->recv_size += recvcounts[i];