int main(int argc, char **argv)
{
int ret, rank, size;
starpu_data_handle_t handle;
int var;
MPI_Init(&argc, &argv);
starpu_mpi_comm_rank(MPI_COMM_WORLD, &rank);
starpu_mpi_comm_size(MPI_COMM_WORLD, &size);
ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
ret = starpu_mpi_init(NULL, NULL, 0);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_init");
if (size<3)
{
FPRINTF(stderr, "We need more than 2 processes.\n");
starpu_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
return STARPU_TEST_SKIPPED;
}
if (rank == 0)
{
int n;
for(n=1 ; n<size ; n++)
{
MPI_Status status;
FPRINTF_MPI(stderr, "receiving from node %d\n", n);
starpu_variable_data_register(&handle, STARPU_MAIN_RAM, (uintptr_t)&var, sizeof(var));
starpu_mpi_recv(handle, n, 42, MPI_COMM_WORLD, &status);
starpu_data_acquire(handle, STARPU_R);
STARPU_ASSERT_MSG(var == n, "Received incorrect value <%d> from node <%d>\n", var, n);
FPRINTF_MPI(stderr, "received <%d> from node %d\n", var, n);
starpu_data_release(handle);
starpu_data_unregister(handle);
}
}
else
{
FPRINTF_MPI(stderr, "sending to node %d\n", 0);
var = rank;
starpu_variable_data_register(&handle, STARPU_MAIN_RAM, (uintptr_t)&var, sizeof(var));
starpu_mpi_send(handle, 0, 42, MPI_COMM_WORLD);
starpu_data_unregister(handle);
}
starpu_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
return 0;
}
int main(int argc, char **argv)
{
int ret=0, global_ret=0;
int rank, size;
MPI_Init(&argc, &argv);
starpu_mpi_comm_rank(MPI_COMM_WORLD, &rank);
starpu_mpi_comm_size(MPI_COMM_WORLD, &size);
ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
ret = starpu_mpi_init(NULL, NULL, 0);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_init");
if (size%2 != 0)
{
FPRINTF(stderr, "We need a even number of processes.\n");
starpu_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
return STARPU_TEST_SKIPPED;
}
ret = exchange_variable(rank, 0);
if (ret != 0) global_ret = ret;
ret = exchange_variable(rank, 1);
if (ret != 0) global_ret = ret;
ret = exchange_void(rank, 0);
if (ret != 0) global_ret = ret;
ret = exchange_void(rank, 1);
if (ret != 0) global_ret = ret;
ret = exchange_complex(rank, 0);
if (ret != 0) global_ret = ret;
ret = exchange_complex(rank, 1);
if (ret != 0) global_ret = ret;
starpu_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
return global_ret;
}
void _starpu_mpi_cache_stats_init(MPI_Comm comm)
{
stats_enabled = starpu_get_env_number("STARPU_MPI_CACHE_STATS");
if (stats_enabled == -1)
{
stats_enabled = 0;
}
if (stats_enabled == 0) return;
if (!getenv("STARPU_SILENT")) fprintf(stderr,"Warning: StarPU is executed with STARPU_MPI_CACHE_STATS=1, which slows down a bit\n");
starpu_mpi_comm_size(comm, &world_size);
_STARPU_MPI_DEBUG(1, "allocating for %d nodes\n", world_size);
comm_cache_amount = (size_t *) calloc(world_size, sizeof(size_t));
}
int main(int argc, char **argv)
{
int size, n, x=789;
int rank, other_rank;
int ret;
starpu_data_handle_t data[2];
MPI_Init(&argc, &argv);
starpu_mpi_comm_rank(MPI_COMM_WORLD, &rank);
starpu_mpi_comm_size(MPI_COMM_WORLD, &size);
if (size % 2)
{
FPRINTF(stderr, "We need a even number of processes.\n");
MPI_Finalize();
return STARPU_TEST_SKIPPED;
}
other_rank = rank%2 == 0 ? rank+1 : rank-1;
FPRINTF_MPI(stderr, "rank %d exchanging with rank %d\n", rank, other_rank);
if (rank % 2)
{
MPI_Send(&rank, 1, MPI_INT, other_rank, 10, MPI_COMM_WORLD);
FPRINTF(stderr, "[%d] sending %d\n", rank, rank);
}
else
{
MPI_Recv(&x, 1, MPI_INT, other_rank, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
FPRINTF(stderr, "[%d] received %d\n", rank, x);
}
ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
ret = starpu_mpi_init(NULL, NULL, 0);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_init");
if (rank % 2)
{
starpu_variable_data_register(&data[0], STARPU_MAIN_RAM, (uintptr_t)&rank, sizeof(unsigned));
starpu_variable_data_register(&data[1], STARPU_MAIN_RAM, (uintptr_t)&rank, sizeof(unsigned));
starpu_mpi_data_register(data[1], 22, 0);
}
else
starpu_variable_data_register(&data[0], -1, (uintptr_t)NULL, sizeof(unsigned));
starpu_mpi_data_register(data[0], 12, 0);
if (rank % 2)
{
starpu_mpi_req req;
starpu_mpi_issend(data[1], &req, other_rank, 22, MPI_COMM_WORLD);
starpu_mpi_send(data[0], other_rank, 12, MPI_COMM_WORLD);
starpu_mpi_wait(&req, MPI_STATUS_IGNORE);
}
else
{
int *xx;
starpu_mpi_recv(data[0], other_rank, 12, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
xx = (int *)starpu_variable_get_local_ptr(data[0]);
FPRINTF_MPI(stderr, "received %d\n", *xx);
STARPU_ASSERT_MSG(x==*xx, "Received value %d is incorrect (should be %d)\n", *xx, x);
starpu_variable_data_register(&data[1], -1, (uintptr_t)NULL, sizeof(unsigned));
starpu_mpi_data_register(data[1], 22, 0);
starpu_mpi_recv(data[0], other_rank, 22, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
xx = (int *)starpu_variable_get_local_ptr(data[0]);
STARPU_ASSERT_MSG(x==*xx, "Received value %d is incorrect (should be %d)\n", *xx, x);
}
starpu_data_unregister(data[0]);
starpu_data_unregister(data[1]);
starpu_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
return 0;
}
int main(int argc, char **argv)
{
int rank, nodes;
int ret=0;
int compare=0;
ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
ret = starpu_mpi_init(&argc, &argv, 1);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_init");
starpu_mpi_comm_rank(MPI_COMM_WORLD, &rank);
starpu_mpi_comm_size(MPI_COMM_WORLD, &nodes);
if (nodes < 2)
{
fprintf(stderr, "This program needs at least 2 nodes (%d available)\n", nodes);
ret = 77;
}
else
{
starpu_data_handle_t handle;
starpu_data_handle_t handle2;
double real[2] = {4.0, 2.0};
double imaginary[2] = {7.0, 9.0};
double real2[2] = {14.0, 12.0};
double imaginary2[2] = {17.0, 19.0};
if (rank == 1)
{
real[0] = 0.0;
real[1] = 0.0;
imaginary[0] = 0.0;
imaginary[1] = 0.0;
}
starpu_complex_data_register(&handle, STARPU_MAIN_RAM, real, imaginary, 2);
starpu_complex_data_register(&handle2, -1, real2, imaginary2, 2);
if (rank == 0)
{
int *compare_ptr = &compare;
starpu_task_insert(&cl_display, STARPU_VALUE, "node0 initial value", strlen("node0 initial value")+1, STARPU_R, handle, 0);
starpu_mpi_isend_detached(handle, 1, 10, MPI_COMM_WORLD, NULL, NULL);
starpu_mpi_irecv_detached(handle2, 1, 20, MPI_COMM_WORLD, NULL, NULL);
starpu_task_insert(&cl_display, STARPU_VALUE, "node0 received value", strlen("node0 received value")+1, STARPU_R, handle2, 0);
starpu_task_insert(&cl_compare, STARPU_R, handle, STARPU_R, handle2, STARPU_VALUE, &compare_ptr, sizeof(compare_ptr), 0);
}
else if (rank == 1)
{
starpu_mpi_irecv_detached(handle, 0, 10, MPI_COMM_WORLD, NULL, NULL);
starpu_task_insert(&cl_display, STARPU_VALUE, "node1 received value", strlen("node1 received value")+1, STARPU_R, handle, 0);
starpu_mpi_isend_detached(handle, 0, 20, MPI_COMM_WORLD, NULL, NULL);
}
starpu_task_wait_for_all();
starpu_data_unregister(handle);
starpu_data_unregister(handle2);
}
starpu_mpi_shutdown();
starpu_shutdown();
if (rank == 0) return !compare; else return ret;
}
