static void report()

in Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/MemoryLog.java [509:596]
69 lines of code
4 McCabe index (conditional complexity)

  static void report(ExtrememThread t, boolean reportCSV,
                     MemoryLog alloc_log, MemoryLog discard_log) {
       
    int lifespans = LifeSpan.OrdinalCount;
    int flavors = MemoryFlavor.OrdinalCount;
       
    // Report the snapshot of memory usage before generation of this
    // report results in additional allocation and garbage.
    long[][] allocs = new long[lifespans][flavors];
    long[][] discards = new long[lifespans][flavors];
    long[][] deltas = new long[lifespans][flavors];
    for (int i = 0; i < LifeSpan.OrdinalCount; i++) {
      for (int j = 0; j < MemoryFlavor.OrdinalCount; j++) {
        allocs[i][j] = alloc_log.tallies[i][j];
        discards[i][j] = discard_log.tallies[i][j];
        deltas[i][j] = allocs[i][j] - discards[i][j];
      }
    }
    // Account for three temporary arrays (allocs, discards, deltas),
    // each holding five inner arrays.
    MemoryLog log = t.memoryLog();
    Polarity Grow = Polarity.Expand;
    log.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayObject, Grow, 18);
    log.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference,
                   Grow, 3 * 5);
    log.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayRSB,
                   Grow, 3 * 5 * 10 * Util.SizeOfLong);
    
    if (reportCSV) {
      reportCSV(t, allocs, discards, deltas);
    } else {
      reportHeaders();
       
      long[] a_row = allocs[LifeSpan.Ephemeral.ordinal()];
      long[] d_row = discards[LifeSpan.Ephemeral.ordinal()];
      long[] delta_row = deltas[LifeSpan.Ephemeral.ordinal()];

      reportOneRow(t, "", a_row);
      reportOneRow(t, "Ephemeral", d_row);
      reportCumulativeOneRow(t, "", null, delta_row);
      reportDivider();
       
      a_row = allocs[LifeSpan.TransientShort.ordinal()];
      d_row = discards[LifeSpan.TransientShort.ordinal()];
      delta_row = deltas[LifeSpan.TransientShort.ordinal()];

      reportOneRow(t, "", a_row);
      reportOneRow(t, "Transient", d_row);
      reportCumulativeOneRow(t, "Short", null, delta_row);
      reportDivider();

      a_row = allocs[LifeSpan.TransientIntermediate.ordinal()];
      d_row = discards[LifeSpan.TransientIntermediate.ordinal()];
      delta_row = deltas[LifeSpan.TransientIntermediate.ordinal()];

      reportOneRow(t, "", a_row);
      reportOneRow(t, "Transient", d_row);
      reportCumulativeOneRow(t, "Intermediate", null, delta_row);
      reportDivider();

      a_row = allocs[LifeSpan.TransientLingering.ordinal()];
      d_row = discards[LifeSpan.TransientLingering.ordinal()];
      delta_row = deltas[LifeSpan.TransientLingering.ordinal()];

      reportOneRow(t, "", a_row);
      reportOneRow(t, "Transient", d_row);
      reportCumulativeOneRow(t, "Lingering", null, delta_row);
      reportDivider();

      a_row = allocs[LifeSpan.NearlyForever.ordinal()];
      d_row = discards[LifeSpan.NearlyForever.ordinal()];
      delta_row = deltas[LifeSpan.NearlyForever.ordinal()];

      reportOneRow(t, "", a_row);
      reportOneRow(t, "NearlyForever", d_row);
      reportCumulativeOneRow(t, "", null, delta_row);
      reportDivider();
    }
    MemoryLog garbage = t.garbageLog();
    // accumulate the allocs, discards, and deltas arrays, each with
    // five inner arrays.
    garbage.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayObject,
                       Grow, 18);
    garbage.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference,
                       Grow, 3 * 5);
    garbage.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayRSB,
                       Grow, 3 * 5 * 10 * Util.SizeOfLong);
  }