Параллельные методы сортировки

// Программа 9.1. 
// Обобщенная быстрая сортировка
int ProcRank;       // Ранг текущего процесса
int ProcNum;        // Количество процессов
int main(int argc, char *argv[]) {
  double *pProcData;     // Блок данных процесса 
  int     ProcDataSize;  // Размер блока данных

  MPI_Init(&argc, &argv);
  MPI_Comm_rank(MPI_COMM_WORLD, &ProcRank);
  MPI_Comm_size(MPI_COMM_WORLD, &ProcNum);

  // Инициализация данных и их распределение между процессами
  ProcessInitialization(&pProcData, &ProcDataSize);

  // Параллельная сортировка 
  ParallelHyperQuickSort(pProcData, ProcDataSize);

  // Завершение вычислений процесса
  ProcessTermination(pProcData, ProcDataSize);

  MPI_Finalize();
}

// Функция для выполнения обощенного алгоритма быстрой сортировки
void ParallelHyperQuickSort ( double *pProcData, 
  int ProcDataSize) { 
  MPI_Status status;
  int CommProcRank;	// Ранг процессора, с которым выполняется 
							// взаимодействие
  double *pData,    	// Часть блока, остающаяся на процессоре
         *pSendData,	// Часть блока, передаваемая процессору 
 							// CommProcRank
         *pRecvData,	// Часть блока, получаемая от процессора 
							// CommProcRank
         *pMergeData; // Блок данных, получаемый после слияния
  int     DataSize, SendDataSize, RecvDataSize, MergeDataSize;
  int HypercubeDim = (int)ceil(log(ProcNum)/log(2)); 
							// размерность гиперкуба
  int Mask = ProcNum; 
  double Pivot; 

  // Первоначальная сортировка блоков данных на каждом процессоре  
  LocalDataSort(pProcData, ProcDataSize); 

  // Итерации обобщенной быстрой сортировки
  for (int i = HypercubeDim; i > 0; i-- ) {

    // Определение ведущего значения и его рассылка всем процессорам
    PivotDistribution(pProcData, ProcDataSize, HypercubeDim,
      Mask, i,&Pivot);
    Mask = Mask >> 1;

    // Определение границы разделения блока
    int pos = GetProcDataDivisionPos(pProcData, ProcDataSize, Pivot);

    // Разделение блока на части
    if ( ( (rank & Mask) >> (i - 1) ) == 0 ) { // старший бит = 0 
      pSendData = &pProcData[pos + 1];
      SendDataSize = ProcDataSize - pos – 1;
      if (SendDataSize < 0) SendDataSize = 0;
      CommProcRank = ProcRank + Mask
      pData = &pProcData[0];
      DataSize = pos + 1; 
    }
    else { // старший бит = 1
      pSendData = &pProcData[0];
      SendDataSize = pos + 1;
      if (SendDataSize > ProcDataSize) SendDataSize = pos;
      CommProcRank = ProcRank – Mask
      pData = &pProcData[pos + 1];
      DataSize = ProcDataSize - pos - 1; 
      if (DataSize < 0) DataSize = 0;
    }
    // Пересылка размеров частей блоков данных
    MPI_Sendrecv(&SendDataSize, 1, MPI_INT, CommProcRank, 0, 
      &RecvDataSize, 1, MPI_INT, CommProcRank, 0, MPI_COMM_WORLD, &status);

    // Пересылка частей блоков данных
    pRecvData = new double[RecvDataSize];
    MPI_Sendrecv(pSendData, SendDataSize, MPI_DOUBLE,
      CommProcRank, 0, pRecvData, RecvDataSize, MPI_DOUBLE,
      CommProcRank, 0, MPI_COMM_WORLD, &status);
    
    // Слияние частей
    MergeDataSize = DataSize + RecvDataSize;
    pMergeData = new double[MergeDataSize];
    DataMerge(pMergeData, pMergeData, pData, DataSize, 
      pRecvData, RecvDataSize); 
    delete [] pProcData;
    delete [] pRecvData;
    pProcData = pMergeData;
    ProcDataSize = MergeDataSize; 
  }
}

// Функция выбора и рассылки ведущего элемента
void PivotDistribution (double *pProcData, int ProcDataSize, int Dim, 
  int Mask, int Iter, double *pPivot) {
  MPI_Group WorldGroup; 
  MPI_Group SubcubeGroup; // Группа процессов — подгиперкуб
  MPI_Comm  SubcubeComm;  // Коммуникатор подгиперкуба
  int j = 0;
  
  int  GroupNum = ProcNum /(int)pow(2, Dim-Iter);
  int *ProcRanks = new int [GroupNum]; 

  // формирование списка рангов процессов для гиперкуба
  int StartProc = ProcRank – GroupNum;
  if (StartProc < 0) StartProc = 0;
  int EndProc = ProcRank + GroupNum;
  if (EndProc > ProcNum) EndProc = ProcNum;
  for (int proc = StartProc; proc < EndProc; proc++) {
    if ((ProcRank & Mask)>>(Iter) == (proc & Mask)>>(Iter)) {
      ProcRanks[j++] = proc; 
    }
  }
  // Объединение процессов подгиперкуба в одну группу  
  MPI_Comm_group(MPI_COMM_WORLD, &WorldGroup); 
  MPI_Group_incl(WorldGroup, GroupNum, ProcRanks, &SubcubeGroup);  
  MPI_Comm_create(MPI_COMM_WORLD, SubcubeGroup, &SubcubeComm);
    
  // Поиск и рассылка ведущего элемента всем процессам подгиперкуба
  if (ProcRank == ProcRanks[0])
    *pPivot = pProcData[ProcDataSize / 2];

  MPI_Bcast(pPivot, 1, MPI_DOUBLE, 0, SubcubeComm);
  MPI_Group_free(&SubcubeGroup);
  MPI_Comm_free(&SubcubeComm);
  delete [] ProcRanks;
}