The Vibrating String

Transcription

1 CS 789 Multiprocessor Programming The Vibrating String School of Computer Science Howard Hughes College of Engineering University of Nevada, Las Vegas (c) Matt Pedersen, 200 P P2 P3 P4

2 The One-Dimensional Wave Equation The time-dependent motion of a simple vibrating string is described by the hyperbolic partial differential equation: 2 ψ c 2 t 2 2 ψ x 2 = 0 The solution ψ(x, t) is the vibration amplitude expressed as a function of position and time. The problem becomes fully posed with the addition of boundary conditions on the spatial domain, and initial position and velocity distribution. While an analytic solution may be obtained by elementary methods, we shall solve the problem by a numerical method which lends itself to a natural concurrent decomposition. This may not be the best way to solve such a simple problem, but it serves as a useful example for the solution of larger or more difficult problems that are not as amenable to analytic methods. Your program for the numerical solution of this equation will be to propose a uniform discretization of the spatial and temporal domains, and approximate the partial differential equation. by a finite difference expression. if x and t represent the space and time step size respectively, and ψ i represents the approximate solution at the i th nodal point in the spatial discretization, then the second order finite difference equation becomes: ψ i (t t) 2ψ i (t) + ψ i (t + t) c 2 t 2 ψ i (t) 2ψ i (t) + ψ i+ (t) x 2 = 0 Neglecting issues of solutions stability, the straightforward scheme for solving this system involves stepping sequentially from one time step to the next using the relation: ψ i (t + t) = 2ψ i (t) ψ(t t) + τ 2 (ψ i (t) 2ψ I (t) + ψ i+ (t)) where τ = c t/ x. As you can see from the equation, we work with a number of discrete points spaced evenly between the two endpoints of the string. The number of points should be taken in as a parameter. As we discussed in class, the easiest way to decompose this problem for parallelization is to use a master/slave approach and give each slave an equal number of points (the last or the first might get a few more or less if the number of points is not divisible by the number of processors). Looking at the equation above, we see that in order to calculate the position of point i (ψ i (t + t)) at time t + (t + t) we need the current position of point i (ψ i (t)), the position of point i at time t (t t), and the positions of the two neighbouring points at time t (ψ i (t) and ψ i+ (t)). We will keep the information about the position of the points at time t in an array called yold, the positions of the points at time t in an array called y, and then calculate the new positions at time t + in an array called ynew. We initialize both y and yold to be a simple sine function. 2 The Parallel Version We wish to implement the parallel version as a master slave system, with inter-slave communication. Here is the pseudo code for both the master and the slave:

3 2. Pseudo code for Master Decode command line parameters (*) Send parameters to slaves (*) Receive results from slaves Write result to file 2.2 Postcode for Slave Receive parameters from master (*) Set up a portion of the string (initialize x, y etc) Repeat s times: { if rank= Send right point to 2 Receive left point from 2 else if rank=n Send left point to n- Receive right point from n- else Send left point to n- Send right point to n+ Receive left point from n+ Receive right point from n-; Compute Send results back to master (*) If you want, you could compute the correct parameters in each slave and avoid some communication - that would be totally ok. 3 The Sequential Version I have written the following sequential version that you can use as a reference point. If you pick extreme values the solution can diverge and you get a strange looking result. The result should be a sine-wave with extreme values between - and. Try the following: 2

4 - "result.txt" Wave "result.txt" Wave "result.txt" Wave Each of the above results are plotted with the Gnuplot command plot [*:*] [-:] result.txt. 3

5 4 What to Do. Implement a master/slave version of the program using MPI. 2. Perform a number of parallel runs to ensure that the parallel version computes the same as the sequential version (this one is available on the webpage). 3. Measure and report speedups. 4. Briefly explain why this program is more sensitive to load difference than the processor farm implementation for Mandelbrot. 5. Suggest a way to implement this program such that load balancing is taken into account. 6. For a fixed size problem (or a reasonable size that gives runtimes around at least 2 minutes for the sequential version) use timers to measure the parts of the parallel program that cannot be parallelized (i.e., typically file IO in the master etc.) and use this time to determine the maximum speedup that you should be able to achieve. Did you get the speed up you expected? 4

6 /* Wave master.c */ #include <stdio.h> #include <stdlib.h> #include <math.h> int main(int argc, char *argv[ ]) { int n; int nb; long double l; long double dt; 0 int steps; FILE *y file; long double *x, *y, *yold, *ynew; long double pi, tau, dx; int i,s; if (argc!= 6) { printf("usage: wave <l> <nb> <n> <steps> <dt>\n"); printf("\t l \t = Total length of the string (x-axis).\n"); printf("\t nb \t = Number of half sine waves.\n"); 20 printf("\t n \t = Number of nodes (number of discrete points on the x-axis between 0 printf("\t steps \t = Number of steps.\n"); printf("\t dt \t = Size of each step.\n%d args supplied\n",argc); exit(0); /* Get variables from commando line */ l = atof(argv[]); nb = atoi(argv[2]); n = atoi(argv[3]); 30 steps = atoi(argv[4]); dt = atof(argv[5]); /* set variables */ pi = 4.0 * atan(); dx = l/(n ); tau = 2.0*l*dt/nb/dx; /* allocate space for arrays */ x = (long double *) calloc(n,sizeof(long double)); 40 y = (long double *) calloc(n,sizeof(long double)); yold = (long double *) calloc(n,sizeof(long double)); ynew = (long double *) calloc(n,sizeof(long double)); /* initialize x-array */ 5

7 for (i=0; i<n; i++) x[i] = l*i/(n ); /* initialize y*-arrays */ for (i=0; i<n; i++) { 50 if ((i==0) (i == n )) y[i] = yold[i] = ynew[i] = 0.0; else y[i] = yold[i] = sin(pi*nb*x[i]/l); /* Perform calculations */ for (s=0; s<steps; s++) { for (i=; i<n ; i++) { ynew[i] = 2*y[i] yold[i]+tau*tau*(y[i ] 2*y[i]+y[i+]); 60 for (i=; i<n ; i++) { yold[i] = y[i]; y[i] = ynew[i]; /* Write the result to a file*/ y file = fopen("result.txt", "w" ); if (y file == (FILE *)NULL) { 70 printf("could not open output file.\n"); exit(); for (i=0; i<n; i++) fprintf(y file,"%5.9f %5.9f\n",(double)( l * i )/( n ),(double) y[i]); fclose(y file); return 0; 6