int MPI_Send(void* buf, int count, MPI_Datatype datatype, int dest,
            int msgtag, MPI_Comm comm);

int MPI_Recv(void* buf, int count, MPI_Datatype datatype, int source,
            int tag, MPI_Comm comm, MPI_Status* status);

MPI_Status status;
MPI_Recv(&buffer, 1, MPI_Float, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status)
tag = status.MPI_SOURCE
source = status.MPI_SOURCE

#include <stdio.h>
#include <time.h>
#include "mpi.h"
#define RETURN return 0
#define FIRST_THREAD 0
int* get_interval(int, int, int*);
inline void print_simple_range(int, int);
void wait(int);
int main(int argc, char **argv)
{
  // инициализируем необходимые переменные
  int thread, thread_size, processor_name_length;
  int* thread_range, interval;
  double cpu_time_start, cpu_time_fini;
  char* processor_name = new char[MPI_MAX_PROCESSOR_NAME * sizeof(char)];
  MPI_Status status;
  interval = new int[2];
  // Инициализируем работу MPI
  MPI_Init(&argc, &argv);
  // Получаем имя физического процессора
  MPI_Get_processor_name(processor_name, &processor_name_length);
  // Получаем номер конкретного процесса на котором запущена программа
  MPI_Comm_rank(MPI_COMM_WORLD, &thread);
  // Получаем количество запущенных процессов
  MPI_Comm_size(MPI_COMM_WORLD, &thread_size);
  // Если это первый процесс, то выполняем следующий участок кода
  if(thread == FIRST_THREAD)
  {
    // Выводим информацию о запуске
    printf("----- Programm information -----\n");
    printf(">>> Processor: %s\n", processor_name);
    printf(">>> Num threads: %d\n", thread_size);
    printf(">>> Input the interval: ");
    // Просим пользователья ввести интервал на котором будут вычисления
    scanf("%d %d", &interval[0], &interval[1]);
    // Каждому процессу отправляем полученный интервал с тегом сообщения 0.
    for (int to_thread = 1; to_thread < thread_size; to_thread++)
      MPI_Send(&interval, 2, MPI_INT, to_thread, 0, MPI_COMM_WORLD);
    // Начинаем считать время выполнения
    cpu_time_start = MPI_Wtime();
  }
  // Если процесс не первый, тогда ожидаем получения данных
  else
    MPI_Recv(&interval, 2, MPI_INT, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
  // Все процессы запрашивают свой интервал
  range = get_interval(thread, thread_size, interval);
  // После чего отправляют полученный интервал в функцию которая производит вычисления
  print_simple_range(range[0], range[1]);
  // Последний процесс фиксирует время завершения, ожидает 1 секунду и выводит результат
  if(thread == thread_size - 1)
  {
    cpu_time_fini = MPI_Wtime();
    wait(1);
    printf("CPU Time: %lf ms\n", (cpu_time_fini - cpu_time_start) * 1000);
  }
  MPI_Finalize();
  RETURN;
}
int* get_interval(int proc, int size, int interval)
{
  // Функция для рассчета интервала каждого процесса
  int* range = new int[2];
  int interval_size = (interval[1] - interval[0]) / size;
  range[0] = interval[0] + interval_size * proc;
  range[1] = interval[0] + interval_size * (proc + 1);
  range[1] = range[1] == interval[1] - 1 ? interval[1] : range[1];
  return range;
}
inline void print_simple_range(int ibeg, int iend)
{
  // Прострейшая реализация определения простого числа
  bool res;
  for(int i = ibeg; i <= iend; i++)
  {
    res = true;
    while(res)
    {
      res = false;
      for(int j = 2; j < i; j++) if(i % j == 0) res = true;
      if(res) break;
    }
    res = not res;
    if(res) printf("Simple value ---> %d\n", i);
  }
}
void wait(int seconds)
{
  // Функция ожидающая в течение seconds секунд
  clock_t endwait;
  endwait = clock () + seconds * CLOCKS_PER_SEC ;
  while (clock() < endwait) {};
}

int MPI_Get_count(MPI_Status* status, MPI_Datatype datatype, int* count);

int MPI_Probe(int source, int tag, MPI_Comm comm, MPI_Status* status);

#include <iostream>
#include "mpi.h"
using namespace std;
void show_arr(int* arr, int size)
{
  for(int i=0; i < size; i++) cout << arr[i] << " ";
  cout << endl;
}
int main(int argc, char **argv)
{
  int size, rank;
  MPI_Init(&argc, &argv);
  MPI_Comm_size(MPI_COMM_WORLD, &size);
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  if(rank == 0)
  {
    int* arr = new int[size];
    for(int i=0; i < size; i++) arr[i] = i;
    for(int i=1; i < size; i++) MPI_Send(arr, i, MPI_INT, i, 5, MPI_COMM_WORLD);
  }
  else
  {
    int count;
    MPI_Status status;
    MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
    MPI_Get_count(&status, MPI_INT, &count);
    int* buf = new int[count];
    MPI_Recv(buf, count, MPI_INT, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
    cout << "Process:" << rank << " || Count: " << count << " || Array: ";
    show_arr(buf, count);
  }
  MPI_Finalize();
  return 0;
}

Process:1 || Count: 1 || Array: 0
Process:2 || Count: 2 || Array: 0 1
Process:4 || Count: 4 || Array: 0 1 2 3
Process:3 || Count: 3 || Array: 0 1 2