GCPerformance.java - GC Performance Test Program

Java 8 GC Tutorials - Herong's Tutorial Examples

∟Garbage Collection Performance Test Program

∟GCPerformance.java - GC Performance Test Program

This section describes a GC performance test program - GCPerformance.java.

In previous tutorials of the book, we learned how different garbage collectors work. Now in order to learn how to tune garbage collectors to improve application performance, I wrote the following test program:

/* GCPerformance.java
 * Copyright (c) HerongYang.com. All Rights Reserved.
 */
class GCPerformance {
   static MyList objList = null;
   static int objSize = 1024; // in KB, default = 1 MB
   static int baseSize = 32;  // # of objects in the base
   static int chunkSize = 32; // # of objects in chunk
   static int wait = 1000;    // in milliseconds: 1 second
   static int warmup = 256;   // warmup loops: 256*32 = 8GB
   public static void main(String[] arg) {
      if (arg.length>0) objSize = Integer.parseInt(arg[0]);
      if (arg.length>1) baseSize = Integer.parseInt(arg[1]);
      if (arg.length>2) chunkSize = Integer.parseInt(arg[2]);
      if (arg.length>3) wait = Integer.parseInt(arg[3]);
      if (arg.length>4) warmup = Integer.parseInt(arg[4]);
      System.out.println("Parameters: "+"Size="+objSize+"KB"
         +", Base="+baseSize +", Chunk="+chunkSize
         +", Wait="+wait+"ms" +", Warmup="+warmup);
      objList = new MyList();
      myTest();
   }
   public static void myTest() {
      for (int m=0; m<baseSize; m++) {
         objList.add(new MyObject());
      }
      for (int k=0; k<warmup; k++) {
         for (int m=0; m<chunkSize; m++) {
            objList.add(new MyObject());
         }
         for (int m=0; m<chunkSize; m++) {
            objList.removeTail();
         }
      }

      Runtime rt = Runtime.getRuntime();
      System.out.println("Real:Exec  Lat.     Throughput      "
         +"Total:Free  Proc.");
      System.out.println("Time:Time  ms/o  Ave:Min:Max:Chunk  "
         +" Mem.:Mem.   Obj.");
      long dt0 = System.currentTimeMillis();
      long dt1 = System.currentTimeMillis();
      long minPerf = 999999;
      long maxPerf = 0;
      long count = 0;
      while (true) {
         for (int m=0; m<chunkSize; m++) {
            objList.add(new MyObject());
         }
         for (int m=0; m<chunkSize; m++) {
            objList.removeTail();
         }
         count++;

         mySleep(wait);
         long tm = rt.totalMemory()/1024;
         long fm = rt.freeMemory()/1024;
         long dt2 = System.currentTimeMillis();
         long dt = dt2 - dt0;
         long de = dt - (count*wait);
         long perf = (1000*chunkSize)/(dt2-dt1-wait); // per second
         if (perf<minPerf) minPerf = perf;
         if (perf>maxPerf) maxPerf = perf;

         System.out.println((dt)      // Real time in millis
            +":"+(de)                 // Execution time in millis
            +"  "+(1000000/minPerf)   // Latency (ms/1000 objects)
            +"  "+((1000*count*chunkSize)/de) // Average throughput
            +":"+minPerf              // Best throughput
            +":"+maxPerf              // Worst throughput
            +":"+perf                 // Chunk throughput
            +"  "+tm+":"+fm           // Total and free memory in KB
            +"  "+(count*chunkSize)); // Objects processed
         dt1 = dt2;
      }
   }
   static void mySleep(int t) {
      try {
         Thread.sleep(t);
      } catch (InterruptedException e) {
         System.out.println("Interreupted...");
      }
   }

   static class MyObject {
      private long[] obj = null;
      public MyObject next = null;
      public MyObject prev = null;
      public MyObject() {
         obj = new long[objSize*128]; // 128*8=1024 bytes
         for (int i=0; i<objSize*128; i++) {
            obj[i] = i/2+i/3+i/4+i/5; // some work load
         }
      }
   }
   static class MyList {
      MyObject head = null;
      MyObject tail = null;
      void add(MyObject o) {
         if (head==null) {
            head = o;
            tail = o;
         } else {
            o.prev = head;
            head.next = o;
            head = o;
         }
      }
      void removeTail() {
         if (tail!=null) {
            if (tail.next==null) {
               tail = null;
               head = null;
            } else {
               tail = tail.next;
               tail.prev = null;
            }
         }
      }
   }
}

Some notes on the test program:

An inner class MyObject is used to represent a generic object. The size of the object can be controlled by the "objSize" parameter.
Another inner class MyList is used to as a manager to register and release objects. It uses a linked list data structure to do the job.
The main test method, myTest(), is divided two sections: initialization/warmup and test run. section where a number of objects are added to the linked list; and the endless loop section where objects are added to the linked list, then removed from the list.
The initialization/warmup section performs two tasks: initialization of the link list base controlled by the "baseSize" parameter; and warmup of the heap by processing some chunks of objects controlled by the "warmup" parameter.
The test run section is an endless loop. In each iteration of the loop, "chunkSize" number of new objects will be added to the linked list, and "chunkSize" number of old objects will be removed.
You can slowdown the loop by using the "wait" parameter to wait for some milliseconds in each iteration.

The output of the test program focuses on two performance metrics:

Throughput - Defined as "the number of objects processed per second". This is calculated as:

After each chunk of objects is processed, we calculate the throughput of this chunk as the chunk size divided by the execution time of this chunk.
The execution time is calculated as the elapsed time minus the wait time.
Normalization is needed to express throughput as "objects per second"
Then the best and worst throughputs are recorded when chunks are occurred processed.
The overall throughput is calculated as the total number of processed divided by the total execution time.

Latency - Defined as "the maximum time required to process a single object". This is calculated as:

The chunk that has the worst throughput is used to calculate the latency, because less objects processed means more time needed to process each object.
The overall latency is calculated by as the multiplicative inverse of the worst throughput.
Normalization is needed to express latency as "milliseconds per 1000 objects"