Пример #1
0
int main(int   argc,    char *argv[]) {
    init_list_body_data();


    int  nbodies, x, y;
    Window win; // initialization for a window
    GC gc; // graphics context
    Display *display = NULL;
    unsigned int width = X_RESN, height = Y_RESN; /* window size */
    clock_t start, end, elapsed;



    int rank;
    int size;

    MPI_Init (&argc, &argv);      /* starts MPI */
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);        /* get current process id */
    MPI_Comm_size(MPI_COMM_WORLD, &size);        /* get number of processes */



    // I follow this topic
    // http://stackoverflow.com/questions/9864510/struct-serialization-in-c-and-transfer-over-mpi
    // alow MPI tranfer truct data type
    const int       num_of_item = 8;
    int             blocklengths[8] = {1, 1, 1, 1, 1, 1, 1, 1};
    MPI_Datatype    types[8] = {MPI_DOUBLE, MPI_DOUBLE, MPI_DOUBLE, MPI_DOUBLE, MPI_DOUBLE, MPI_DOUBLE, MPI_DOUBLE, MPI_INT};
    MPI_Datatype    mpi_body_type;
    MPI_Aint        offsets[8];

    offsets[0] = offsetof(body, position_x);
    offsets[1] = offsetof(body, position_y);
    offsets[2] = offsetof(body, velocity_x);
    offsets[3] = offsetof(body, velocity_y);
    offsets[4] = offsetof(body, force_x);
    offsets[5] = offsetof(body, force_y);
    offsets[6] = offsetof(body, mass);
    offsets[7] = offsetof(body, body_id);

    MPI_Type_create_struct(num_of_item, blocklengths, offsets, types, &mpi_body_type);
    MPI_Type_commit(&mpi_body_type);





    //
    // http://stackoverflow.com/questions/11246150/synchronizing-master-slave-model-with-mpi
    // for master/slave
    int j = 0;
    int i = 0;
    int k = 0;
    int num_of_move =100;
    int index = 0;
    int p;


    int steps = MAX_BODY / (size - 1);

    if (( MAX_BODY % (size - 1)) > 0) {
        steps++;
    }
    if(rank == 0)
    {
        display = x11setup(&win, &gc, width, height);
        // other setup code in the master
    }
    for (j = 0; j < num_of_move; j++) {
        //which number of moves  process complte!?
        if(rank == 0) {
            printf("Processed %d of %d\n", j, num_of_move);
        }
        for (k = 0; k < MAX_BODY; k ++) {

            index = 0;
            for (i = 0; i <  steps; i++ ) {

                if(rank == 0) { //master
                    for(p = 1; p < size; p++){

                        body a =  list_body[k];
                        body b =  list_body[index];
                        if (index >= MAX_BODY -1) {
                            b = list_body[MAX_BODY -1];
                        }
                        // send 2 body to calculate force
                        MPI_Send(&a, 1, mpi_body_type, p, 20, MPI_COMM_WORLD);
                        MPI_Send(&b, 1, mpi_body_type, p, 20, MPI_COMM_WORLD);

                        //recieve result
                        body b_recv;
                        MPI_Recv(&b_recv, 1, mpi_body_type, p, 21, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

                        //update to list
                        list_body[k] = b_recv;
                        index++;
                    }

                }
                else { //workers

                    //receive 2 body to calculate force
                    body  a;
                    MPI_Recv(&a, 1, mpi_body_type, 0, 20, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
                    body  b;
                    MPI_Recv(&b, 1, mpi_body_type, 0, 20, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

                    // calculating....
                    update_body_force(&a, &b);
                    update_body_velocity(&a);
                    update_body_location(&a);

                    // finish! send body a to master
                    MPI_Send(&a, 1, mpi_body_type, 0, 21, MPI_COMM_WORLD);
                }
            }
        }
        if(rank == 0) {
            XClearWindow(display, win);
            for (i = 0; i < MAX_BODY; i++) { // draw the bodies on the display
                body b = list_body[i];
                // this function will draw a circle inside a 3x3 box with the upper left
                // corner at (x,y). N.b. the last 2 arguments mean that it will fill from
                // 0 to 360 degrees - a full circle
                if (i == 0) {
                    XFillArc(display, win, gc, b.position_x , b.position_y, 6, 6, 0, 23040);
                }
                XFillArc(display, win, gc, b.position_x , b.position_y, 3, 3, 0, 23040);

                // you campicould also use XDrawPoint(display, win, gc, x, y) to draw a single
                // pixel at (x,y)
            }
            XFlush(display);
            //reset force
            for (i = 0; i < MAX_BODY; i++) {
                    body *b = & list_body[i];

                    b->force_x = 0;
                    b->force_y = 0;
            }

        }


        usleep(100 * 1000);

    }
    // finaly, use rank=0 (master) to output result
    if (rank == 0) {
        i = 0;
        for (i = 0; i < MAX_BODY; i++) {
            body_info(list_body[i]);
        }
    }



    // main loop
//    int running = 1; // loop variable
//    start = clock();
//    while(running) {

//        // checks to see if there have been any events,
//        // will exit the main loop if any key is pressed
//        if(rank==0) {
//            if(XPending(display)) {
//                XEvent ev;
//                XNextEvent(display, &ev);
//                switch(ev.type) {
//                    case KeyPress:
//                        running = 0;
//                        break;
//                }
//            }
//        }


        // your code to calculate the forces on the bodies goes here


//        end = clock();
//        elapsed = end - start;
//        // only update the display if > 1 millisecond has passed since the last update
//        if(elapsed / (CLOCKS_PER_SEC/1000) > 1 && rank==0) {
//            XClearWindow(display, win);
//            for (i = 0; i < MAX_BODY; i++) { // draw the bodies on the display
//                body b = list_body[i];
//                // this function will draw a circle inside a 3x3 box with the upper left
//                // corner at (x,y). N.b. the last 2 arguments mean that it will fill from
//                // 0 to 360 degrees - a full circle
//                XFillArc(display, win, gc, b.position_x , b.position_y, 3, 3, 0, 23040);

//                // you campicould also use XDrawPoint(display, win, gc, x, y) to draw a single
//                // pixel at (x,y)
//            }
//            start = end;
//            XFlush(display);
//        }
//    }

//    if(rank==0 && display) {
//        XCloseDisplay(display); // close the display window
//    }


    MPI_Finalize();


    return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
	int rank, nprocs, x, y;
	Window win; // initialization for a window
	GC gc; // graphics context
	Display *display = NULL;
	Colormap screenColourmap;
	XColor colours[15];
	unsigned int width = X_RESN, height = Y_RESN; /* window size */
	clock_t start, end, elapsed;
	int pixelToDraw[3];
	MPI_Init(&argc, &argv); 
	MPI_Comm_size(MPI_COMM_WORLD, &nprocs); 
	MPI_Comm_rank(MPI_COMM_WORLD, &rank);

	ComplexNumber c;
	ComplexNumber z;
	int depth = 1000;
	int cSize = 4;
	double cX = -2;
	double cY = -2;
	double cMinR = cX;
	double cMinI = cY;
	double cMaxR = cMinR + cSize;
	double cMaxI = cMinI + cSize;
	double increaseX = (cMaxR - cMinR) / X_RESN;
	double increaseY = (cMaxI - cMinI) / Y_RESN;
	int drawable[X_RESN][Y_RESN];
        
	if(rank==0)
	{
		display = x11setup(&win, &gc, width, height);
		screenColourmap = DefaultColormap(display, DefaultScreen(display));
		setupColours(display, colours, screenColourmap);
		int probeFlag = 0;
		MPI_Status status;
		int count = 0;
		int start = 1;
		for (int i = 1; i < nprocs; i++) {
			MPI_Send(&start, 1, MPI_INT, i, 98, MPI_COMM_WORLD);
		}
		for (int y = 0; y < Y_RESN; y++) {
			for (int x = 0; x < X_RESN; x++) {
				while (!probeFlag) {
					MPI_Iprobe(MPI_ANY_SOURCE, 99, MPI_COMM_WORLD, &probeFlag, &status);
					if (probeFlag) {
						int coords[2] = {x, y};
						int slave = status.MPI_SOURCE;
						MPI_Recv(&pixelToDraw, 3, MPI_INT, MPI_ANY_SOURCE, 99, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
						MPI_Send(&coords, 2, MPI_INT, slave, 99, MPI_COMM_WORLD); 
						drawable[pixelToDraw[0]][pixelToDraw[1]] = pixelToDraw[2];
						count++;
					} else {
						MPI_Iprobe(MPI_ANY_SOURCE, 98, MPI_COMM_WORLD, &probeFlag, &status);
						if (probeFlag) {
							int slave = status.MPI_SOURCE;
							int coords[2] = {x, y};
							MPI_Recv(&start, 1, MPI_INT, MPI_ANY_SOURCE, 98, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
							MPI_Send(&coords, 2, MPI_INT, slave, 99, MPI_COMM_WORLD); 
						}
					}
				}
				probeFlag = 0;
			}
		}
		MPI_Recv(&pixelToDraw, 3, MPI_INT, MPI_ANY_SOURCE, 99, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
		drawable[pixelToDraw[0]][pixelToDraw[1]] = pixelToDraw[2];
		for (int y = 0; y < Y_RESN; y++) {
			for (int x = 0; x < X_RESN; x++) {
				drawPoint(display, win, gc, colours, x, y, depth, drawable[x][y]);
			}
		}
	} else {
		int flag = 1;
		int coords[2];
		MPI_Recv(&start, 1, MPI_INT, 0, 98, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
		MPI_Send(&start, 1, MPI_INT, 0, 98, MPI_COMM_WORLD);
		while (flag) {
			MPI_Recv(&coords, 2, MPI_INT, 0, 99, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
			c.r = coords[0] * increaseX - 2;
			c.i = coords[1] * increaseY - 2;
			resetComplexNumber(&z);
			int limit = seriesDiverges(depth, &z, &c);
			pixelToDraw[0] = coords[0];
			pixelToDraw[1] = coords[1];
			pixelToDraw[2] = limit;
			MPI_Send(&pixelToDraw, 3, MPI_INT, 0, 99, MPI_COMM_WORLD);
		}
	}
	
	// main loop
	int running = 1; // loop variable
	start = clock();
	while(running) {
	
		// checks to see if there have been any events,
		// will exit the main loop if any key is pressed
		if(rank==0) {
			if(XPending(display)) {
				XEvent ev;
				XNextEvent(display, &ev);
				switch(ev.type) {
					case KeyPress:
						running = 0;
						break;
				}
			}
		}
		
		end = clock();
		elapsed = end - start;
		// only update the display if > 1 millisecond has passed since the last update
		if(elapsed / (CLOCKS_PER_SEC/1000) > 1 && rank==0) {
			//XClearWindow(display, win);
			start = end;
			XFlush(display);
		}
	}

	if(rank==0 && display) {
		XCloseDisplay(display); // close the display window
		printf("Display closed\n");
	} else {
		MPI_Finalize();
		return 0;
	}
	
	MPI_Finalize();
	return 0;
}