SHARE
TWEET

Untitled

a guest May 19th, 2017 43 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include "mpi.h"
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <conio.h>
  5. #include <string.h>
  6. #include <math.h>
  7. #include <time.h>
  8. #include <cstdio>
  9. #include <iostream>
  10.  
  11. int main(int argc, char* argv[])
  12. {
  13.     int porog = 1000000;
  14.     using namespace std;
  15.     setlocale(LC_ALL, "Russian");
  16.     int *chisla, *chisla_buf;
  17.     int myrank, size;
  18.     int num_proc;
  19.     int TAG=0;
  20.     double startwtime, endwtime;
  21.     FILE *prchisla;
  22.     MPI_Status status;
  23.     int fl;
  24.     int diapason, ost, start, end;
  25.     int i, j, flag;
  26.     int buf, kol;
  27.     MPI_Init(&argc, &argv); // Инициализируем работу программы MPI
  28.     MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
  29.     // Определяем общее число процессов
  30.     MPI_Comm_size(MPI_COMM_WORLD, &size);
  31.     if (myrank == 0) // Если это главный процесс, то
  32.     {
  33.         fopen_s(&prchisla, "result.txt", "w");
  34.         startwtime = MPI_Wtime();
  35.         diapason = porog / size;
  36.         ost = porog - diapason*size;
  37.         // Главный процесс посылает всем остальным процессам диапазон анализа
  38.         MPI_Bcast(&diapason, 1, MPI_INT, 0, MPI_COMM_WORLD);
  39.         MPI_Barrier(MPI_COMM_WORLD);
  40.         // Ожидаем пока все процессы получат данные
  41.         start = (size - 1)*diapason + 2;
  42.         end = (size*diapason) + ost;
  43.         chisla = (int*)malloc((diapason + ost) * sizeof(int));
  44.         chisla_buf = (int*)malloc(diapason * sizeof(int));
  45.         for (i = 0; i < (diapason + ost); i++)
  46.             chisla[i] = 0;
  47.         for (i = 0; i < diapason; i++)
  48.             chisla_buf[i] = 0;
  49.         kol = 0;
  50.         if (start == 2)
  51.         {
  52.             chisla[kol] = 2;
  53.             kol++;
  54.             start = start + 1;
  55.         }
  56.         for (i = start; i <= end; i++)
  57.         {
  58.             j = 1;
  59.             flag = 1;
  60.             do
  61.             {
  62.                 j++;
  63.                 if (i % j == 0)
  64.                     flag = 0;
  65.             } while ((j < sqrt(i) + 1) && (flag == 1));
  66.             if (flag == 1)
  67.             {
  68.                 chisla[kol] = i;
  69.                 kol++;
  70.             }
  71.         }
  72.         if (size > 1)
  73.         {
  74.             for (j = 1; j < size; j++)
  75.             {
  76.                 // то принимаем данные от каждого из них
  77.                 num_proc = j;
  78.                 MPI_Recv(chisla_buf, diapason, MPI_INT, num_proc,
  79.                     TAG, MPI_COMM_WORLD, &status);
  80.                 i = 0;
  81.                 while ((i < diapason) && (chisla_buf[i] != 0))
  82.                 {
  83.                     if (chisla_buf[i] != 0)
  84.                     {
  85.                         fprintf(prchisla, "%d \n", chisla_buf[i]);
  86.                         fflush(prchisla);
  87.                     }
  88.                     i++;
  89.                 }
  90.             }
  91.         }
  92.         i = 0;
  93.         while ((i < (diapason + ost)) && (chisla[i] != 0))
  94.         {
  95.             if (chisla[i] != 0)
  96.             {
  97.                 fprintf(prchisla, "%d \n", chisla[i]);
  98.             }
  99.             i++;
  100.         }
  101.         MPI_Barrier(MPI_COMM_WORLD);
  102.         endwtime = MPI_Wtime();
  103.         printf("\ntime = %f\n", endwtime - startwtime);
  104.         printf("\nEnd of analys!\n");
  105.         free(chisla);
  106.         free(chisla_buf);
  107.         fclose(prchisla);
  108.     }
  109.  
  110.     else
  111.     {
  112.         MPI_Bcast(&diapason, 1, MPI_INT, 0, MPI_COMM_WORLD);
  113.         printf("\nProccess %d get data from main process, diapazon = %d\n", myrank, diapason);
  114.         MPI_Barrier(MPI_COMM_WORLD);
  115.         start = (myrank - 1) * diapason + 2;
  116.         end = (myrank*diapason) + 1;
  117.         chisla = (int *)malloc(diapason * sizeof(int));
  118.         for (i = 0; i < (diapason); i++)
  119.             chisla[i] = 0;
  120.         kol = 0;
  121.         if (start == 2)
  122.         {
  123.             chisla[kol] = 2;
  124.             kol++;
  125.             start++;
  126.         }
  127.         for (i = start; i <= end; i++)
  128.         {
  129.             j = 1;
  130.             flag = 1;
  131.             do
  132.             {
  133.                 j++;
  134.                 if (i % j == 0)
  135.                     flag = 0;
  136.             } while ((j < sqrt(i) + 1) && (flag == 1));
  137.             if (flag == 1)
  138.             {
  139.                 chisla[kol] = i;
  140.                 kol++;
  141.             }
  142.         }
  143.         MPI_Send(chisla, diapason, MPI_INT, 0, TAG, MPI_COMM_WORLD);
  144.         MPI_Barrier(MPI_COMM_WORLD);
  145.     }
  146.     MPI_Finalize(); // Завершаем работу программы MPI
  147.     return 0;
  148. }
RAW Paste Data
Top