Then, you can pass the option --cfg=smpi/shared-malloc-hugepage:/home/huge
to smpirun to actually activate the huge page support in shared mallocs.
-@subsection options_model_smpi_wtime smpi/wtime: Inject constant times for calls to MPI_Wtime
+@subsection options_model_smpi_wtime smpi/wtime: Inject constant times for calls to MPI_Wtime, gettimeofday and clock_gettime
-@b Default value: 0
-
-By setting this option, you can control the amount of time a process sleeps
-when MPI_Wtime() is called; this is important, because SimGrid normally only
-advances the time while communication is happening and thus,
-MPI_Wtime will not add to the time, resulting in a deadlock if used as a
-break-condition.
+@b Default value: 1ms
-Here is an example:
+This option controls the amount of (simulated) time spent in calls to
+MPI_Wtime(), gettimeofday() and clock_gettime(). If you set this value
+to 0, the simulated clock is not advanced in these calls, which leads
+to issue if your application contains such a loop:
@code{.unparsed}
while(MPI_Wtime() < some_time_bound) {
- ...
+ /* some tests, with no communication nor computation */
}
@endcode
-If the time is never advanced, this loop will clearly never end as MPI_Wtime()
-always returns the same value. Hence, pass a (small) value to the smpi/wtime
-option to force a call to MPI_Wtime to advance the time as well.
-
+When the option smpi/wtime is set to 0, the time advances only on
+communications and computations, so the previous code results in an
+infinite loop: the current [simulated] time will never reach @c
+some_time_bound. This infinite loop is avoided when that option is
+set to a small amount, as it is by default since SimGrid v3.21.
+
+Note that if your application does not contain any loop depending on
+the current time only, then setting this option to a non-zero value
+will slow down your simulations by a tiny bit: the simulation loop has
+to be broken and reset each time your code ask for the current time.
+If the simulation speed really matters to you, you can avoid this
+extra delay by setting smpi/wtime to 0.
@section options_generic Configuring other aspects of SimGrid
When **communicating**, data is not directly sent to other actors but
posted onto a |Mailbox|_ that serves as a rendez-vous point between
communicating actors. This means that you don't need to know who you
-are talking to, you just put your communication `Send` request in a
-mailbox, and it will be matched with a complementary `Receive`
+are talking to, you just put your communication `Put` request in a
+mailbox, and it will be matched with a complementary `Get`
request. Alternatively, actors can interact through **classical
synchronization mechanisms** such as |Barrier|_, |Semaphore|_,
|Mutex|_ and |ConditionVariable|_.
.. literalinclude:: ../../examples/s4u/async-waitall/s4u-async-waitall.cpp
:language: c++
- :start-after: send-begin
- :end-before: send-end
+ :start-after: put-begin
+ :end-before: put-end
:dedent: 4
pending_comms.push_back(comm);
}
- /* Start sending messages to let the workers know that they should stop */ // sphinx-doc: send-begin
+ /* Start sending messages to let the workers know that they should stop */ // sphinx-doc: put-begin
for (int i = 0; i < receivers_count; i++) {
XBT_INFO("Send 'finalize' to 'receiver-%d'", i);
simgrid::s4u::CommPtr comm = mboxes[i]->put_async(new std::string("finalize"), 0);
/* Now that all message exchanges were initiated, wait for their completion in one single call */
simgrid::s4u::Comm::wait_all(&pending_comms);
- // sphinx-doc: send-end
+ // sphinx-doc: put-end
XBT_INFO("Goodbye now!");
}
namespace kernel {
namespace context {
-class ThreadContext : public AttachContext {
+class XBT_PUBLIC ThreadContext : public AttachContext {
public:
ThreadContext(std::function<void()> code, void_pfn_smxprocess_t cleanup_func, smx_actor_t process, bool maestro);
~ThreadContext() override;
static void* wrapper(void *param);
};
-class SerialThreadContext : public ThreadContext {
+class XBT_PUBLIC SerialThreadContext : public ThreadContext {
public:
SerialThreadContext(std::function<void()> code, void_pfn_smxprocess_t cleanup_func, smx_actor_t process, bool maestro)
: ThreadContext(std::move(code), cleanup_func, process, maestro)
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_bench, smpi, "Logging specific to SMPI (benchmarking)");
+static simgrid::config::Flag<double>
+ smpi_wtime_sleep("smpi/wtime",
+ "Minimum time to inject inside a call to MPI_Wtime(), gettimeofday() and clock_gettime()",
+ 1e-6 /* Documented to be 1ms */);
+
double smpi_cpu_threshold = -1;
double smpi_host_speed;
double smpi_total_benched_time = 0;
extern "C" XBT_PUBLIC void smpi_execute_flops_(double* flops);
+
void smpi_execute_flops_(double *flops)
{
smpi_execute_flops(*flops);
smpi_total_benched_time += xbt_os_timer_elapsed(timer);
}
-/* Private sleep function used by smpi_sleep() and smpi_usleep() */
+/* Private sleep function used by smpi_sleep(), smpi_usleep() and friends */
static unsigned int private_sleep(double secs)
{
smpi_bench_end();
tv->tv_usec = static_cast<suseconds_t>((now - tv->tv_sec) * 1e6);
#endif
}
+ if (smpi_wtime_sleep > 0)
+ simcall_process_sleep(smpi_wtime_sleep);
smpi_bench_begin();
return 0;
}
tp->tv_sec = static_cast<time_t>(now);
tp->tv_nsec = static_cast<long int>((now - tp->tv_sec) * 1e9);
}
+ if (smpi_wtime_sleep > 0)
+ simcall_process_sleep(smpi_wtime_sleep);
smpi_bench_begin();
return 0;
}
#endif
+double smpi_mpi_wtime()
+{
+ double time;
+ if (smpi_process()->initialized() && not smpi_process()->finalized() && not smpi_process()->sampling()) {
+ smpi_bench_end();
+ time = SIMIX_get_clock();
+ if (smpi_wtime_sleep > 0)
+ simcall_process_sleep(smpi_wtime_sleep);
+ smpi_bench_begin();
+ } else {
+ time = SIMIX_get_clock();
+ }
+ return time;
+}
+
extern double sg_surf_precision;
unsigned long long smpi_rastro_resolution ()
{
// No instance gets manually created; check also the smpirun.in script as
// this default name is used there as well (when the <actor> tag is generated).
static const std::string smpi_default_instance_name("smpirun");
-static simgrid::config::Flag<double> smpi_wtime_sleep(
- "smpi/wtime", "Minimum time to inject inside a call to MPI_Wtime", 0.0);
static simgrid::config::Flag<double> smpi_init_sleep(
"smpi/init", "Time to inject inside a call to MPI_Init", 0.0);
if(smpi_init_sleep > 0)
simcall_process_sleep(smpi_init_sleep);
}
-
-double smpi_mpi_wtime(){
- double time;
- if (smpi_process()->initialized() != 0 && smpi_process()->finalized() == 0 && smpi_process()->sampling() == 0) {
- smpi_bench_end();
- time = SIMIX_get_clock();
- // to avoid deadlocks if used as a break condition, such as
- // while (MPI_Wtime(...) < time_limit) {
- // ....
- // }
- // because the time will not normally advance when only calls to MPI_Wtime
- // are made -> deadlock (MPI_Wtime never reaches the time limit)
- if(smpi_wtime_sleep > 0)
- simcall_process_sleep(smpi_wtime_sleep);
- smpi_bench_begin();
- } else {
- time = SIMIX_get_clock();
- }
- return time;
-}
-
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 2)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
// sleep (30);
}
else if (rank == 2)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
// sleep (60);
}
else if (rank == 2)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
// sleep (30);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
// sleep (60);
}
else if (rank == 2)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
//sleep (30);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
//sleep (60);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
// sleep (60);
}
else if (rank == 2)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 2)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
//sleep (60);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 2)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
}
else if (rank == 2)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 2)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
// sleep (30);
}
else if (rank == 2)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
// sleep (30);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
// sleep (30);
}
else if (rank == 2)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
}
else if (rank == 2)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
// sleep (30);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
}
else if (rank == 2)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
}
else if (rank == 2)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
// sleep (30);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
}
else if (rank == 2)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
// sleep (30);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
- memset (buf1, 1, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Irecv (buf1, buf_size, MPI_INT,
MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Irecv (buf0, buf_size, MPI_INT,
MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Irecv (buf1, buf_size, MPI_INT,
MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Irecv (buf1, buf_size, MPI_INT,
MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
{
MPI_Recv (buf0, buf_size, MPI_INT, 0, 2, MPI_COMM_WORLD, statuses);
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Isend (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &reqs[0]);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Recv (buf1, buf_size, MPI_INT, 0, 1, MPI_COMM_WORLD, &status);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Isend (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &reqs[0]);
if (dnprocs > 1) {
if (drank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Recv (buf1, buf_size, MPI_INT, 1, 0, comm, &status);
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, comm);
}
else if (drank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, comm, &status);
if (dnprocs > 1) {
if (drank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Recv (buf1, buf_size, MPI_INT, 1, 0, comm, &status);
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, comm);
}
else if (drank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, comm, &status);
if (dnprocs > 1) {
if (drank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Recv (buf1, buf_size, MPI_INT, 1, 0, comm, &status);
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, comm);
}
else if (drank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, comm, &status);
MPI_Comm_dup (MPI_COMM_WORLD, &comm);
if (rank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Recv (buf1, buf_size, MPI_INT, 1, 0, comm, &status);
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, comm);
}
else if (rank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, comm, &status);
if (dnprocs > 1) {
if (drank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Recv (buf1, buf_size, MPI_INT, 1, 0, comm, &status);
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, comm);
}
else if (drank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, comm, &status);
if (dnprocs > 1) {
if (drank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Recv (buf1, buf_size, MPI_INT, 1, 0, comm, &status);
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, comm);
}
else if (drank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, comm, &status);
if (rnprocs > drank) {
if (rank % 2) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, drank, 0, intercomm, &status);
MPI_Send (buf1, buf_size, MPI_INT, drank, 0, intercomm);
}
else {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Recv (buf1, buf_size, MPI_INT, drank, 0, intercomm, &status);
if (dnprocs > 1) {
if (drank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Recv (buf1, buf_size, MPI_INT, 1, 0, comm, &status);
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, comm);
}
else if (drank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, comm, &status);
}
else if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Recv (buf1, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &status);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &status);
fflush (stdout);
if (rank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Bcast (buf0, buf_size, MPI_INT, 1, MPI_COMM_WORLD);
MPI_Bcast (buf0, buf_size, MPI_INT, 0, MPI_COMM_WORLD);
}
else {
if (rank == 1)
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Bcast (buf0, buf_size, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast (buf0, buf_size, MPI_INT, 1, MPI_COMM_WORLD);
printf ("(%d) is alive on %s\n", rank, processor_name);
fflush (stdout);
- memset (sbuf, 0, buf_size);
- memset (rbuf, 1, buf_size);
+ memset (sbuf, 0, buf_size*sizeof(int));
+ memset (rbuf, 1, buf_size*sizeof(int));
MPI_Barrier (comm);
printf ("(%d) is alive on %s\n", rank, processor_name);
fflush (stdout);
- memset (buf0, 0, buf_size);
- memset (buf1, 1, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Barrier (comm);
MPI_Barrier (comm);
printf ("(%d) is alive on %s\n", rank, processor_name);
fflush (stdout);
- memset (buf0, 0, buf_size);
- memset (buf1, 1, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Barrier (comm);
MPI_Barrier (comm);
}
else if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
zero_to_two = 1;
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &status);
else if ((rank == 1) && (its_raining))
{
/* This code is never executed... */
- memset (buf0, 1, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (tnprocs > 1) {
if (trank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, temp);
}
if (rnprocs > drank) {
if (rank % 2) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, drank, 0, intercomm, &status);
MPI_Send (buf1, buf_size, MPI_INT, drank, 0, intercomm);
}
else {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, drank, 0, intercomm);
INTERCOMM_CREATE_TAG, &intercomm);
if ((trank == 0) && !(rank % 2)) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, temp);
}
if (rnprocs > drank) {
if (rank % 2) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, drank, 0, intercomm, &status);
MPI_Send (buf1, buf_size, MPI_INT, drank, 0, intercomm);
}
else {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, drank, 0, intercomm);
INTERCOMM_CREATE_TAG, &intercomm);
if (rank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD);
}
if (rnprocs > drank) {
if (rank % 2) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, drank, 0, intercomm, &status);
MPI_Send (buf1, buf_size, MPI_INT, drank, 0, intercomm);
}
else {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, drank, 0, intercomm);
INTERCOMM_CREATE_TAG, &intercomm);
if (rank == 2) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, rleader, 0, MPI_COMM_WORLD);
}
else if (rank == 1) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (rnprocs > drank) {
if (rank % 2) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, drank, 0, intercomm, &status);
MPI_Send (buf1, buf_size, MPI_INT, drank, 0, intercomm);
}
else {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, drank, 0, intercomm);
if (dnprocs > 1) {
if (drank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, comm, &status);
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, comm);
}
else if (drank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, comm);
if (dnprocs > 1) {
if (drank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, comm2, &status);
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, comm2);
}
else if (drank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, comm2);
{
int dest = (rank == nprocs - 1) ? (0) : (rank + 1);
int src = (rank == 0) ? (nprocs - 1) : (rank - 1);
- memset (buf0, rank, buf_size);
+ memset (buf0, rank, buf_size*sizeof(int));
MPI_Irecv (buf0, buf_size, MPI_INT, src, 0, MPI_COMM_WORLD, &req);
MPI_Wait(&req,&status);
MPI_Send (buf0, buf_size, MPI_INT, dest, 0, MPI_COMM_WORLD);
{
int dest = (rank == nprocs - 1) ? (0) : (rank + 1);
int src = (rank == 0) ? (nprocs - 1) : (rank - 1);
- memset (buf0, rank, buf_size);
- memset (buf1, rank, buf_size);
+ memset (buf0, rank, buf_size*sizeof(int));
+ memset (buf1, rank, buf_size*sizeof(int));
MPI_Irecv (buf0, buf_size, MPI_INT, src, 0, MPI_COMM_WORLD, &req1);
MPI_Isend (buf1, buf_size, MPI_INT, dest, 0, MPI_COMM_WORLD, &req2);
MPI_Wait(&req2,&status);
{
int dest = (rank == nprocs - 1) ? (0) : (rank + 1);
int src = (rank == 0) ? (nprocs - 1) : (rank - 1);
- memset (buf0, rank, buf_size);
- memset (buf1, rank, buf_size);
+ memset (buf0, rank, buf_size*sizeof(int));
+ memset (buf1, rank, buf_size*sizeof(int));
for (i = 0; i < req_count; i++) {
MPI_Irecv (buf0, buf_size, MPI_INT, src, 0, MPI_COMM_WORLD, &req1);
printf ("(%d) is alive on %s\n", rank, processor_name);
fflush (stdout);
- memset (buf0, 0, buf_size);
- memset (buf1, 1, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
+ memset (buf1, 1, buf_size*sizeof(int));
/* 0 sends 1 two messages, but the request gets overwritten */
switch (rank)
printf ("(%d) is alive on %s\n", rank, processor_name);
fflush (stdout);
- memset (buf0, 1, buf_size);
- memset (buf1, 2, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
+ memset (buf1, 2, buf_size*sizeof(int));
MPI_Barrier(MPI_COMM_WORLD);
{
case 0:
for (i = 0; i < ITERATIONS; i++) {
- memset (buf, 1, buf_size * REQS_PER_ITERATION);
+ memset (buf, 1, buf_size*sizeof(int) * REQS_PER_ITERATION);
for (j = 0; j < REQS_PER_ITERATION; j++) {
MPI_Isend (&buf[j*buf_size], buf_size, MPI_INT,
case 1:
for (i = 0; i < ITERATIONS; i++) {
- memset (buf, 2, buf_size * REQS_PER_ITERATION);
+ memset (buf, 2, buf_size*sizeof(int) * REQS_PER_ITERATION);
for (j = 0; j < REQS_PER_ITERATION; j++) {
MPI_Irecv (&buf[j*buf_size], buf_size, MPI_INT,
}
}
else {
- memset (buf, 1, buf_size);
+ memset (buf, 1, buf_size*sizeof(int));
MPI_Send (buf, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
}
}
else {
- memset (buf, 1, buf_size);
+ memset (buf, 1, buf_size*sizeof(int));
MPI_Send (buf, buf_size, MPI_INT, 0, 0, dcomms[i]);
}
}
else if ((rank % 3) == 2) {
for (j = 0; j < intersize; j++) {
- memset (buf, 1, buf_size);
+ memset (buf, 1, buf_size*sizeof(int));
MPI_Send (buf, buf_size, MPI_INT, j, 0, intercomm);
}
}
}
else {
- memset (buf, 1, buf_size);
+ memset (buf, 1, buf_size*sizeof(int));
MPI_Send (buf, buf_size, MPI_INT, 0, 0, dcomms[i]);
}
}
else if ((rank % 3) == 2) {
for (j = 0; j < intersize; j++) {
- memset (buf, 1, buf_size);
+ memset (buf, 1, buf_size*sizeof(int));
MPI_Send (buf, buf_size, MPI_INT, j, 0, intercomm);
}
}
else if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Irecv (buf1, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Irecv (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Isend (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &reqs[0]);
}
else if (rank == 1)
{
- memset (buf0, 1, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
for (i = 3; i > 0; i--) {
MPI_Recv (&flipbit, 1, MPI_INT, 0, i, MPI_COMM_WORLD, &status);
}
else if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Irecv (buf1, buf_size, MPI_INT,
MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Irecv (buf0, buf_size, MPI_INT,
MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
- memset (buf1, 1, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Irecv (buf1, buf_size, MPI_INT,
MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Isend (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &reqs[0]);
}
else if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Irecv (buf1, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Irecv (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Irecv (buf1, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Irecv (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 2)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Isend (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &reqs[0]);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Isend (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &reqs[0]);
}
else if (rank == 1)
{
- memset (buf0, 1, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
for (i = 3; i > 0; i--) {
MPI_Recv (&flipbit, 1, MPI_INT,
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
{
MPI_Recv (buf0, buf_size, MPI_INT, 0, 2, MPI_COMM_WORLD, &status);
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Isend (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &reqs[0]);
}
else if (rank == 1)
{
- memset (buf0, 1, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
for (i = 3; i > 0; i--) {
MPI_Recv (&flipbit, 1, MPI_INT, 0, i, MPI_COMM_WORLD, &status);
}
else if (rank == 1)
{
- memset (buf0, 1, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
for (i = 3; i >= 0; i--) {
MPI_Recv (&flipbit, 1, MPI_INT, 0, i, MPI_COMM_WORLD, &status);
{
if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Sendrecv (buf0, buf_size, MPI_INT, 1, 0,
buf1, buf_size, MPI_INT, 1, 0,
{
if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Sendrecv (buf1, buf_size, MPI_INT, 0, 0,
buf0, buf_size, MPI_INT, 0, 0,
src = (rank + 1) % nprocs;
dest = (rank - 1 + nprocs) % nprocs;
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Sendrecv (buf0, buf_size, MPI_INT, dest, 0,
buf1, buf_size, MPI_INT, src, 0, MPI_COMM_WORLD, &status);
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Sendrecv (buf1, buf_size, MPI_INT, src, 0,
buf0, buf_size, MPI_INT, dest, 0, MPI_COMM_WORLD, &status);
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Sendrecv (buf0, buf_size, MPI_INT, dest, 0,
buf1, buf_size, MPI_INT, src, 0, MPI_COMM_WORLD, &status);
}
else {
if (rank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Sendrecv (buf0, buf_size, MPI_INT, 1, 0,
buf1, buf_size, MPI_INT, MPI_ANY_SOURCE, 0,
MPI_COMM_WORLD, &status);
}
else if (rank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT,
MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &status);
}
else {
if (rank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Sendrecv (buf0, buf_size, MPI_INT, 1, 0,
buf1, buf_size, MPI_INT, 1, 0,
MPI_COMM_WORLD, &status);
}
else if (rank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &status);
}
else {
if (rank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send_init (buf0, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &aReq[0]);
MPI_Recv_init (buf1, buf_size, MPI_INT,
MPI_Waitall (2, aReq, aStatus);
- memset (buf0, 1, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
MPI_Startall (2, aReq);
MPI_Waitall (2, aReq, aStatus);
}
else if (rank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv_init (buf0, buf_size, MPI_INT,
MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &aReq[0]);
MPI_Waitall (2, aReq, aStatus);
- memset (buf1, 0, buf_size);
+ memset (buf1, 0, buf_size*sizeof(int));
MPI_Startall (2, aReq);
MPI_Waitall (2, aReq, aStatus);
}
else {
if (rank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send_init (buf0, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &aReq[0]);
MPI_Recv_init (buf1, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &aReq[1]);
MPI_Waitall (2, aReq, aStatus);
- memset (buf0, 1, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
MPI_Startall (2, aReq);
MPI_Waitall (2, aReq, aStatus);
}
else if (rank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv_init (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &aReq[0]);
MPI_Send_init (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &aReq[1]);
MPI_Waitall (2, aReq, aStatus);
- memset (buf1, 0, buf_size);
+ memset (buf1, 0, buf_size*sizeof(int));
MPI_Startall (2, aReq);
}
else {
if (rank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send_init (buf0, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &aReq[0]);
MPI_Recv_init (buf1, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &aReq[1]);
MPI_Waitall (2, aReq, aStatus);
- memset (buf0, 1, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
MPI_Startall (2, aReq);
MPI_Waitall (2, aReq, aStatus);
}
else if (rank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv_init (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &aReq[0]);
MPI_Send_init (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &aReq[1]);
MPI_Waitall (2, aReq, aStatus);
- memset (buf1, 0, buf_size);
+ memset (buf1, 0, buf_size*sizeof(int));
MPI_Startall (2, aReq);
}
else {
if (rank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send_init (buf0, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &aReq[0]);
MPI_Recv_init (buf1, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &aReq[1]);
MPI_Waitall (2, aReq, aStatus);
- memset (buf0, 1, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
MPI_Startall (2, aReq);
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
/* activate a request twice */
MPI_Start (&aReq[0]);
MPI_Waitall (2, aReq, aStatus);
}
else if (rank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv_init (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &aReq[0]);
MPI_Send_init (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &aReq[1]);
MPI_Waitall (2, aReq, aStatus);
- memset (buf1, 0, buf_size);
+ memset (buf1, 0, buf_size*sizeof(int));
MPI_Startall (2, aReq);
}
else {
if (rank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send_init (buf0, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &aReq[0]);
MPI_Recv_init (buf1, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &aReq[1]);
MPI_Waitall (2, aReq, aStatus);
- memset (buf0, 1, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
MPI_Startall (2, aReq);
MPI_Waitall (2, aReq, aStatus);
}
else if (rank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv_init (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &aReq[0]);
MPI_Send_init (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &aReq[1]);
MPI_Waitall (2, aReq, aStatus);
- memset (buf1, 0, buf_size);
+ memset (buf1, 0, buf_size*sizeof(int));
MPI_Startall (2, aReq);
}
else {
if (rank == 0) {
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send_init (buf0, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &aReq[0]);
MPI_Recv_init (buf1, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &aReq[1]);
MPI_Waitall (2, aReq, aStatus);
- memset (buf0, 1, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
MPI_Startall (2, aReq);
MPI_Waitall (2, aReq, aStatus);
}
else if (rank == 1) {
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv_init (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &aReq[0]);
MPI_Send_init (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &aReq[1]);
MPI_Waitall (2, aReq, aStatus);
- memset (buf1, 0, buf_size);
+ memset (buf1, 0, buf_size*sizeof(int));
MPI_Startall (2, aReq);
}
else if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Send (buf0, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD);
MPI_Recv (buf1, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &status);
}
else if (rank == 1)
{
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &status);
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
{
if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Sendrecv (buf0, buf_size, MPI_INT, 1, 0,
buf1, buf_size, MPI_INT, 1, 0,
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Recv (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &status);
}
else if (rank == 2)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Send (buf1, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
else if (rank == 0)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Irecv (buf1, buf_size, MPI_INT, 1, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf1, 1, buf_size);
+ memset (buf1, 1, buf_size*sizeof(int));
MPI_Irecv (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &req);
}
else if (rank == 1)
{
- memset (buf0, 0, buf_size);
+ memset (buf0, 0, buf_size*sizeof(int));
MPI_Isend (buf0, buf_size, MPI_INT, 0, 0, MPI_COMM_WORLD, &reqs[0]);
}
else if (rank == 1)
{
- memset (buf0, 1, buf_size);
+ memset (buf0, 1, buf_size*sizeof(int));
for (i = 3; i > 0; i--) {
MPI_Recv (&flipbit, 1, MPI_INT, 0, i, MPI_COMM_WORLD, &status);