MPI realize the data broadcasting, data sending, data receiving and data synchronization [13] . MPI support several data type, including complex. Although

the MPI program is code, the program is different and it can identified by process ID. Different process has different computation task.

In the MPI program, every process has all the variates and functions. The variates and functions have the same name, but the data in the variate is always not the same. If the process needs to know the data of other process, it needs to communicate. Every process can allocate different memory for a pointer. When the task is different for a process in the 3D gravity forward algorithm, it needs to allocate memory more flexibly [14] [15] .

The gravity forward modeling is that the sum of the anomaly that every cuboid in the model produces. The serial program needs loop computation for 5 times. For the observing point, we need to calculate the point of x direction and y direction. For every point, we need calculate the sum of anomaly that the cell produces for x direction, y direction and z direction. The pseudo-code is following.

For(i=1;i < nx_obs;i++) //observing x direction, nx_obs points

For(j=1;i< ny_obs;i++) //observing x direction, ny_obs points

For(l=1;i < nz_model;i++) //cells along the z direction，the number of cells along z direction is nz_model

For(m=1;i < nx_model;i++) //cells along the x direction，the number of cells along x direction is nz_model

For(n=1;i < ny_model;i++) //cells along the y direction，the number of cells along y direction is nz_model

forwarddata(I,j) =forwarddata (I,j)+forward(I,j,l,m,n)

We analyze the 3d gravity forward algorithm and find that the algorithm needs loop computation for 5 times. The loop is the main work for parallel computation. We can divide the nx_obs into several parts for processes. The computation task that every process in parallel algorithm needs to do is less than that in the serial algorithm. Firstly, we need to divide the computation task into several parts.

count = nx_obs / size; // observing along x direction, nx_obs points. Size is the number of processes

segment = nx_obs %size; //when tasks is allocated for every process equally, segment is the number of remainder

for (i = 0; i < size; i++)

{

if (i < segment)

parr[i] = count + 1;

else

parr[i] = count;

}

Parr is an array. The array records the computation task that every process needs to do. For example, nx_obs is 101, size is 4. We known parr[0] = 26, parr[1] = 25, parr[2] = 25, parr[3] = 25. The processes need to calculate 1 - 26, 27 - 51, 52 - 76, 77 - 101 row data, so every process do smaller task in the MPI algorithm than that in the serial algorithm.

The method uses MPI_Gatherv function to gather result. In the parallel algorithm, the program allocates the computation tasks, and every process only has his data result. If we don’t gather the data result, the process can write a file for the result data. For example the algorithm has 4 processes, we can get 4 files of data. If we want to get the final data result, we need merge 4 files manually. It is very difficult. MPI_Gatherv (forwarddata, count, MPI_FLOAT, forwarddata_all, rcounts, displs, MPI_FLOAT, 0, MPI_COMM_WORLD). The function MPI_Gatherv gathers the forwarddata to forwarddata_all and gathers the data from different process to one process. The length of the data can not the same. It is very useful.

Figure 2 is gravity 3D forward MPI algorithm flow chart. The program allocates the computation tasks to every process, and process 0 is the manager process. It reads the parameter file, and allocates the computation tasks to every process. It broadcasts the parameter to processes, and gathers the data result from processes. Finally, it writes the result file. Other processes receive the parameter, and do the computation tasks. They send the data result to the manager process. At the same time, manager process also do computation task. We will introduce the performing process.

(1) Initial the MPI environment, MPI_INT(). The manager process reads the model data and broadcasts the data to other process, MPI_Bcast().

(2) The manager process allocates the computation tasks according to the task

allocate Table 1. Processes do the tasks separately and get the forward data for every observed point.

(3) After all the processes have done the tasks, the manager process gathers the data.

(4) The manager process writes the data file and finalize the MPI environment, MPI_FINALIZE().

The MPI parallel environment

OS: windows 7

CPU: intel core i7 3.2 Ghz support 8 processes

Memory: 8 GB

Develop language: c

Compiler:visual studo 2010

Parallel environment: mpich2

Command: Mpiexec -np N ./gstd_forward N is the number of processes.

The parallel computation is based on the serial program. According to the characteristics, that process does computation task separately. It distributes the tasks to all processes and never changes other algorithm, so the parallel computation result is the same with the serial program’s result. The study compares the forward result of two programs, the result is the same. We choose a line to draw a picture. In Figure 3, x axis is position of the observed point, y axis is the Δg forward data, dot is the MPI result and plus is the serial algorithm result. We can see that the forward data in 6th row is the same, so it proves the validity of the program.

Analysis of the Table 2 shows that the efficiency is the highest when the number of processes is 2. The speedup changes slightly and the efficiency declines when

the number of processes changes from 4 to 8. The communication of the processes occupy much time when the number of processes increases from 4 to 8. We can see that the effect of parallel algorithm is very obvious. When the number of processes is 8, we can save 52 minutes compared to sequential algorithm.