SortAtoms.h File Reference

Go to the source code of this file.

Functions
void	sortAtomsForCUDA (int *order, const FullAtom *atoms, int nfree, int n)
void	sortAtomsForPatches (int *order, int *breaks, const FullAtom *atoms, int nmgrps, int natoms, int ni, int nj, int nk)
void	sortAtomsForCUDA_SOA (int *__restrict order, int *__restrict unorder, const double *__restrict ax, const double *__restrict ay, const double *__restrict az, int nfree, int n)

Function Documentation

sortAtomsForCUDA()

void sortAtomsForCUDA	(	int *	order,
		const FullAtom *	atoms,
		int	nfree,
		int	n
	)

Definition at line 123 of file SortAtoms.C.

References order, and partition().

Referenced by HomePatch::positionsReady().

                                                                           {

  // partition free atoms
  // CkPrintf("%d %d\n", 0, nfree);
  partition(order, atoms, 0, nfree);

  // partition fixed atoms
  // CkPrintf("%d %d\n", nfree, n);
  partition(order, atoms, nfree, n);

}

sortAtomsForCUDA_SOA()

void sortAtomsForCUDA_SOA	(	int *__restrict	order,
		int *__restrict	unorder,
		const double *__restrict	ax,
		const double *__restrict	ay,
		const double *__restrict	az,
		int	nfree,
		int	n
	)

Definition at line 317 of file SortAtoms.C.

References order, and partition_SOA().

Referenced by HomePatch::positionsReady_SOA().

      {

  // partition free atoms
  // CkPrintf("%d %d\n", 0, nfree);
  partition_SOA(order, ax, ay, az, 0, nfree);

  // partition fixed atoms
  // CkPrintf("%d %d\n", nfree, n);
  partition_SOA(order, ax, ay, az, nfree, n);

  // determine mapping to unsort atoms
  for (int i=0;  i < n;  i++) {
    unorder[order[i]] = i;
  }
}

sortAtomsForPatches()

void sortAtomsForPatches	(	int *	order,
		int *	breaks,
		const FullAtom *	atoms,
		int	nmgrps,
		int	natoms,
		int	ni,
		int	nj,
		int	nk
	)

Definition at line 135 of file SortAtoms.C.

References FullAtom::migrationGroupSize, and order.

Referenced by WorkDistrib::createAtomLists().

                                                 {

//CkPrintf("sorting %d atoms in %d groups to %d x %d x %d\n",
//    natoms, nmgrps, nk, nj, ni);
  std::sort(order, order+nmgrps, sortop_z(atoms));
  int pid = 0;
  int ibegin = 0;
  int nai = 0;
  for ( int ip=0; ip < ni; ++ip ) {
    int naj = nai;
    int targi = nai + (natoms - nai - 1) / (ni - ip) + 1;
    int iend;
    for ( iend=ibegin; iend<nmgrps; ++iend ) { 
      int mgs = atoms[order[iend]].migrationGroupSize;
      if (nai + mgs <= targi) nai += mgs;
      else break;
    }
//CkPrintf("  Z %d %d (%d) %d\n", ibegin, iend, iend-ibegin, nai);
    std::sort(order+ibegin, order+iend, sortop_y(atoms));
    int jbegin = ibegin;
    for ( int jp=0; jp < nj; ++jp ) {
      int nak = naj;
      int targj = naj + (nai - naj - 1) / (nj - jp) + 1;
      int jend;
      for ( jend=jbegin; jend<iend; ++jend ) { 
        int mgs = atoms[order[jend]].migrationGroupSize;
        if (naj + mgs <= targj) naj += mgs;
        else break;
      }

//CkPrintf("    Y %d %d (%d) %d\n", jbegin, jend, jend-jbegin, naj);
      std::sort(order+jbegin, order+jend, sortop_x(atoms));
      int kbegin = jbegin;
      for ( int kp=0; kp < nk; ++kp ) {
        int targk = nak + (naj - nak - 1) / (nk - kp) + 1;
        int kend;  
        for ( kend=kbegin; kend<jend; ++kend ) {
          int mgs = atoms[order[kend]].migrationGroupSize;
          if (nak + mgs <= targk) nak += mgs;
          else break;
//CkPrintf("        atom %d %d %.2f\n", atoms[order[kend]].id, mgs,
//                  atoms[order[kend]].position.x);
        }
//CkPrintf("      X %d %d (%d) %d\n", kbegin, kend, kend-kbegin, nak);
        breaks[pid++] = kend;
        kbegin = kend;
      }
      jbegin = jend;
    }
    ibegin = iend;
  }

}