source: codes/icosagcm/devel/Python/src/partition.c @ 760

#include <mpi.h>
#include <stdio.h>
#include <parmetis.h>

void dynamico_partition_graph(int mpi_rank, int mpi_size, 
                     idx_t vtxdist[], idx_t xadj_loc[], idx_t adjncy_loc[],
                     idx_t nparts, idx_t part[])
{
  MPI_Comm comm = MPI_COMM_WORLD; /* avoid passing a communicator as argument due to Fortran/C issues */
  idx_t edgecut;
  idx_t options[]={0}, wgtflag=0, numflag=0, ncon=1;
  real_t tpwgts[2*nparts], ubvec[]={1.05};

  /* int ParMETIS V3 PartKway (
     idx t *vtxdist, idx t *xadj, idx t *adjncy, idx t *vwgt, idx t *adjwgt, 
     idx t *wgtflag, idx t *numflag, idx t *ncon, idx t *nparts, 
     real t *tpwgts, real t *ubvec, idx t *options, idx t *edgecut, idx t *part, 
     MPI Comm *comm )
  */

/*  printf("sizeof : %d %d \n", sizeof(int), sizeof(idx_t));
  printf("partition_graph : %d %d %d\n", mpi_rank, mpi_size, nparts); 
  printf("vtxdist : \n"); 
  for(int i=0; i<mpi_size+1; i++) printf("%d %d %d\n", mpi_rank, i, vtxdist[i]); */
      
  for(int i=0; i<2*nparts; i++) tpwgts[i] = 1./nparts;
  ParMETIS_V3_PartKway(vtxdist, xadj_loc, adjncy_loc, NULL, NULL, 
                       &wgtflag, &numflag, &ncon, &nparts, 
                       tpwgts, ubvec, options, &edgecut, part, &comm); 
}


// http://www.forceflow.be/2013/10/07/morton-encodingdecoding-through-bit-interleaving-implementations/ 
// method to seperate bits from a given integer 3 positions apart
static inline uint64_t splitBy3(unsigned int a){
  uint64_t x = a & 0x1fffff; // we only look at the first 21 bits
  x = (x | x << 32) & 0x1f00000000ffff;  // shift left 32 bits, OR with self, and 00011111000000000000000000000000000000001111111111111111
  x = (x | x << 16) & 0x1f0000ff0000ff;  // shift left 32 bits, OR with self, and 00011111000000000000000011111111000000000000000011111111
  x = (x | x << 8) & 0x100f00f00f00f00f; // shift left 32 bits, OR with self, and 0001000000001111000000001111000000001111000000001111000000000000
  x = (x | x << 4) & 0x10c30c30c30c30c3; // shift left 32 bits, OR with self, and 0001000011000011000011000011000011000011000011000011000100000000
  x = (x | x << 2) & 0x1249249249249249;
  return x;
}
 
static inline uint64_t mortonEncode_magicbits(unsigned int x, unsigned int y, unsigned int z){
  uint64_t answer = 0;
  answer |= splitBy3(x) | splitBy3(y) << 1 | splitBy3(z) << 2;
  return answer;
}

void dynamico_morton_encode(int n, const int *x, const int *y, const int *z, uint64_t *m)
{
  for(int i=0; i<n; i++)
    m[i]=mortonEncode_magicbits(x[i],y[i],z[i]);
}