proc1.cpp File Reference

#include <mpi.h>
#include <vector>

Include dependency graph for proc1.cpp:

Go to the source code of this file.

Macros
#define	DIETAG   2
#define	WORKTAG   1

Functions
static double	do_work (double *work)
static double *	get_next_work_item ()
int	main (int argc, char **argv)
static void	master (void)
static void	slave (void)

Variables
const int	numEntries = 10
const int	totCalls = 1000

Macro Definition Documentation

#define DIETAG   2

Definition at line 55 of file proc1.cpp.

Referenced by master(), and slave().

#define WORKTAG   1

Definition at line 54 of file proc1.cpp.

Referenced by master().

Function Documentation

static double do_work ( double *  work )

static

Definition at line 223 of file proc1.cpp.

References numEntries.

Referenced by slave().

{
    double tot = 0;
    for (int i =0; i < numEntries; ++i )
        tot += work[i];
}

Here is the caller graph for this function:

static double* get_next_work_item ( )

static

Definition at line 64 of file proc1.cpp.

References numEntries, and totCalls.

Referenced by master().

{

    static vector< double > ret( numEntries );
    static unsigned int numCalls = 0;
    for ( unsigned int i = 0; i < numEntries; ++i )
        ret[i] = i + numCalls;

    numCalls++;
    if ( numCalls > totCalls )
        return 0;
    return &ret[0];
}

Here is the caller graph for this function:

int main	(	int	argc,
		char **	argv
	)

Definition at line 80 of file proc1.cpp.

References master(), and slave().

{
  int myrank;

  /* Initialize MPI */

  MPI_Init(&argc, &argv);

  /* Find out my identity in the default communicator */

  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
  if (myrank == 0) {
    master();
  } else {
    slave();
  }

  /* Shut down MPI */

  MPI_Finalize();
  return 0;
}

Here is the call graph for this function:

static void master ( void  )

static

Definition at line 106 of file proc1.cpp.

References DIETAG, get_next_work_item(), numEntries, totCalls, and WORKTAG.

Referenced by main().

{
  int ntasks, rank;
  double* work;
  double result;
  MPI_Status status;
  double tot = 0.0;
  double tc = totCalls;
  double ne = numEntries;
  double expectedTot =
        tc * ( ( ne * (ne - 1.0) )/2.0 ) +
        ne * ( tc * (tc - 1.0) )/2.0;

  /* Find out how many processes there are in the default
     communicator */

  MPI_Comm_size(MPI_COMM_WORLD, &ntasks);

  /* Seed the slaves; send one unit of work to each slave. */

  for (rank = 1; rank < ntasks; ++rank) {

    /* Find the next item of work to do */

    work = get_next_work_item();

    /* Send it to each rank */

    MPI_Send(work,             /* message buffer */
             numEntries,                 /* one data item */
             MPI_DOUBLE,        /* data item is a double */
             rank,              /* destination process rank */
             WORKTAG,           /* user chosen message tag */
             MPI_COMM_WORLD);   /* default communicator */
  }

  /* Loop over getting new work requests until there is no more work
     to be done */

  work = get_next_work_item();
  while (work != NULL) {

    /* Receive results from a slave */

    MPI_Recv(&result,           /* message buffer */
             1,                 /* one data item */
             MPI_DOUBLE,        /* of type double real */
             MPI_ANY_SOURCE,    /* receive from any sender */
             MPI_ANY_TAG,       /* any type of message */
             MPI_COMM_WORLD,    /* default communicator */
             &status);          /* info about the received message */

    /* Send the slave a new work unit */

    MPI_Send(work,             /* message buffer */
             numEntries,                 /* one data item */
             MPI_DOUBLE,           /* data item is an integer */
             status.MPI_SOURCE, /* to who we just received from */
             WORKTAG,           /* user chosen message tag */
             MPI_COMM_WORLD);   /* default communicator */

    /* Get the next unit of work to be done */

    work = get_next_work_item();
    tot += result;
  }

  /* There's no more work to be done, so receive all the outstanding
     results from the slaves. */

  for (rank = 1; rank < ntasks; ++rank) {
    MPI_Recv(&result, 1, MPI_DOUBLE, MPI_ANY_SOURCE,
             MPI_ANY_TAG, MPI_COMM_WORLD, &status);
    tot += result;
  }

  /* Tell all the slaves to exit by sending an empty message with the
     DIETAG. */

  for (rank = 1; rank < ntasks; ++rank) {
    MPI_Send(0, 0, MPI_INT, rank, DIETAG, MPI_COMM_WORLD);
  }
  cout << "Tot = " << tot << ", expected = " << expectedTot << endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void slave ( void  )

static

Definition at line 193 of file proc1.cpp.

References DIETAG, do_work(), and numEntries.

Referenced by main().

{
  double work[numEntries];
  double result;
  MPI_Status status;

  while (1) {

    /* Receive a message from the master */

    MPI_Recv( work, numEntries, MPI_DOUBLE, 0, MPI_ANY_TAG,
             MPI_COMM_WORLD, &status);

    /* Check the tag of the received message. */

    if (status.MPI_TAG == DIETAG) {
      return;
    }

    /* Do the work */

    result = do_work(work);

    /* Send the result back */

    MPI_Send(&result, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

const int numEntries = 10

Definition at line 60 of file proc1.cpp.

Referenced by do_work(), get_next_work_item(), master(), and slave().

const int totCalls = 1000

Definition at line 61 of file proc1.cpp.

Referenced by get_next_work_item(), and master().