
Leave one free proc.  Permute evenly others.

numProcs
numBlocks

d=numBlocks/(numProcs-2)
r=numBlocks%(numProcs-2)

map:
send first d blocks to 0, next d blocks to 1, ...,
skip myRank, ..., last d blocks to numProcs-2
Remaining r blocks stay where they are.

Receiving d blocks from each of numProcs-2

Initial Values: numBlocks*myRank + j (j=0,...,numBlocks-1)

Send Rank, Indices for Proc i:

for (j = 0; j < i; j++) {
  destRank = j;
  for (k = 0; k < d; k++) {
    destIndex = (i-1)*d+k;
      MADRE_BMAN_setDestination(bman,
                                j*d+k,
                                destRank, destIndex);
    }
  }
}
for (j = i; j < n-2; j++) {
  destRank = j+1;
  for (k = 0; k < d; k++) {
    destIndex = i*d+k;
    for (l = 0...) {
      MADRE_BMAN_setDestination(bman, j*d+k, destRank, destIndex);
  }
}
for (k = 0; k < r; k++) {
  MADRE_BMAN_setDestination(bman, (n-2)*d+k, i, (n-2)*d+k);
}


           Blocks  : rank,  indices

             0..d-1: 0,   (i-1)d..(i)d-1
            d..2d-1: 1,   (i-1)d..(i)d-1
           ...
     (i-1)d..(i)d-1: i-1, (i-1)d..(i)d-1
     (i)d..(i+1)d-1: i+1, (i)d..(i+1)d-1
           ...
   (n-3)d..(n-2)d-1: n-2, (i)d..(i+1)d-1
(n-2)d..numBlocks-1: i, (n-2)d..b-1


Recv Rank, Values for Proc i:
             0..d-1: 0, (i-1)d..(i)d-1
            d..2d-1: 1, b+(i-1)d..b+(i)d-1
              ...
     (i-1)d..(i)d-1: i-1, (i-1)b+(i-1)d..(i-1)b+(i)d-1
     (i)d..(i+1)d-1: i+1, (i+1)b+(i)d..(i+1)b+(i+1)d-1
              ...
   (n-3)d..(n-2)d-1: n-2, (n-2)b+(i)d..(n-2)b+(i+1)d-1
(n-2)d..numBlocks-1: i, ib+(n-2)d..ib+b-1

for (j = 0; j < i; j++) {
  source = j;
  for (k = 0; k < d; k++) {
    index = j*d+k;
    expected = source*b+(i-1)*d+k; ...
  }
}
for (j = i; j < n-2; j++) {
  source = j+1;
  for (k = 0; k < d; k++) {
    index = j*d+k;
    expected = source*b+i*d+k; ...
  }
}
for (k = 0; k < r; k++) {
  index = (n-2)*d+k;
  expcted = i*b+index; ...
}





Receiving indices:

Proc 0: 

  1: 0..d-1                  (d blocks)
  2: d..2d-1                 (d blocks)
  ...
n-2: (n-3)d..(n-2)d-1        (d blocks)
  0: (n-2)d..(n-2)-1         (r blocks)

-----

  0: 0..d-1
  1: d..2d-1
  ...
i-1: (i-1)d..(i)d-1
i+1: (i)d..(i+1)d-1
    ...
n-2: (n-3)d..(n-2)d-1
  i: (n-2)d..n-3




any remaining blocks stay where they are


Proc 0..n-2: full
Proc 