code: public final double[] getZoneTimes(int zoneCount, TimeUnit timeUnit) {
          if (results.length == 0) {
              return new double[0];
          }
          double[] ret = new double[Math.min(zoneCount, results.length)];
          int perblock = results.length / ret.length;
          int overflow = results.length % ret.length;
          int pos = 0;
          double repFactor = unitFactor[timeUnit.ordinal()];
          for (int block = 0; block < ret.length; block++) {
              int count = perblock + (block < overflow ? 1 : 0);
              int limit = pos + count;
              long nanos = 0;
              while (pos < limit) {
                  nanos += results[pos];
                  pos++;
              }
              ret[block] = (nanos / repFactor) / count;
          }
          return ret;
      }
docs: Summarize the time-progression of the run time for each iteration, in
  order of execution (in milliseconds).
  <p>
  An example helps. If there are 200 results, and a request for 10 zones,
  then return 10 double values representing the average time of the first
  20 runs, then the next 20, and so on, until the 10th zone contains the
  average time of the last 20 runs.
  <p>
  This is a good way to see the effects of warm-up times and different
  compile levels
  
  @param zoneCount
  the number of zones to compute
  @param timeUnit
  the unit in which to report the times
  @return an array of times (in the given unit) representing the average
  time for all runs in the respective zone.