test/micro/org/openjdk/bench/vm/lang/LockUnlock.java

*** 52,37 ***
      @Param("100")
      private int innerCount;
  
      public Object lockObject1;
      public Object lockObject2;
      public int factorial;
      public int dummyInt1;
      public int dummyInt2;
  
      @Setup
      public void setup() {
          lockObject1 = new Object();
          lockObject2 = new Object();
          dummyInt1 = 47;
          dummyInt2 = 11; // anything
      }
  
      /** Perform a synchronized on a local object within a loop. */
      @Benchmark
!     public void testSimpleLockUnlock() {
          Object localObject = lockObject1;
          for (int i = 0; i < innerCount; i++) {
              synchronized (localObject) {
                  dummyInt1++;
                  dummyInt2++;
              }
          }
      }
  
      /** Perform a recursive synchronized on a local object within a loop. */
      @Benchmark
!     public void testRecursiveLockUnlock() {
          Object localObject = lockObject1;
          for (int i = 0; i < innerCount; i++) {
              synchronized (localObject) {
                  synchronized (localObject) {
                      dummyInt1++;
--- 52,88 ---
      @Param("100")
      private int innerCount;
  
      public Object lockObject1;
      public Object lockObject2;
+     public volatile Object lockObject3Inflated;
+     public volatile Object lockObject4Inflated;
      public int factorial;
      public int dummyInt1;
      public int dummyInt2;
  
      @Setup
      public void setup() {
          lockObject1 = new Object();
          lockObject2 = new Object();
+         lockObject3Inflated = new Object();
+         lockObject4Inflated = new Object();
+ 
+         // Inflate the lock to use an ObjectMonitor
+         try {
+           synchronized (lockObject3Inflated) {
+             lockObject3Inflated.wait(1);
+           }
+           synchronized (lockObject4Inflated) {
+             lockObject4Inflated.wait(1);
+           }
+         } catch (InterruptedException e) {
+           throw new RuntimeException(e);
+         }
+ 
          dummyInt1 = 47;
          dummyInt2 = 11; // anything
      }
  
      /** Perform a synchronized on a local object within a loop. */
      @Benchmark
!     public void testBasicSimpleLockUnlockLocal() {
          Object localObject = lockObject1;
          for (int i = 0; i < innerCount; i++) {
              synchronized (localObject) {
                  dummyInt1++;
                  dummyInt2++;
              }
          }
      }
  
+     /** Perform a synchronized on an object within a loop. */
+     @Benchmark
+     public void testBasicSimpleLockUnlock() {
+         for (int i = 0; i < innerCount; i++) {
+             synchronized (lockObject1) {
+                 dummyInt1++;
+                 dummyInt2++;
+             }
+         }
+     }
+ 
+     /** Perform a synchronized on a local object within a loop. */
+     @Benchmark
+     public void testInflatedSimpleLockUnlockLocal() {
+         Object localObject = lockObject3Inflated;
+         for (int i = 0; i < innerCount; i++) {
+             synchronized (localObject) {
+                 dummyInt1++;
+                 dummyInt2++;
+             }
+         }
+     }
+ 
+     /** Perform a synchronized on an object within a loop. */
+     @Benchmark
+     public void testInflatedSimpleLockUnlock() {
+         for (int i = 0; i < innerCount; i++) {
+             synchronized (lockObject3Inflated) {
+                 dummyInt1++;
+                 dummyInt2++;
+             }
+         }
+     }
+ 
      /** Perform a recursive synchronized on a local object within a loop. */
      @Benchmark
!     public void testBasicRecursiveLockUnlockLocal() {
          Object localObject = lockObject1;
          for (int i = 0; i < innerCount; i++) {
              synchronized (localObject) {
                  synchronized (localObject) {
                      dummyInt1++;

*** 90,13 ***
                  }
              }
          }
      }
  
      /** Perform two synchronized after each other on the same local object. */
      @Benchmark
!     public void testSerialLockUnlock() {
          Object localObject = lockObject1;
          for (int i = 0; i < innerCount; i++) {
              synchronized (localObject) {
                  dummyInt1++;
              }
--- 141,26 ---
                  }
              }
          }
      }
  
+     /** Perform a recursive synchronized on an object within a loop. */
+     @Benchmark
+     public void testBasicRecursiveLockUnlock() {
+         for (int i = 0; i < innerCount; i++) {
+             synchronized (lockObject1) {
+                 synchronized (lockObject1) {
+                     dummyInt1++;
+                     dummyInt2++;
+                 }
+             }
+         }
+     }
+ 
      /** Perform two synchronized after each other on the same local object. */
      @Benchmark
!     public void testBasicSerialLockUnlockLocal() {
          Object localObject = lockObject1;
          for (int i = 0; i < innerCount; i++) {
              synchronized (localObject) {
                  dummyInt1++;
              }

*** 104,10 ***
--- 168,130 ---
                  dummyInt2++;
              }
          }
      }
  
+   /** Perform two synchronized after each other on the same object. */
+     @Benchmark
+     public void testBasicSerialLockUnlock() {
+         for (int i = 0; i < innerCount; i++) {
+             synchronized (lockObject1) {
+                 dummyInt1++;
+             }
+             synchronized (lockObject1) {
+                 dummyInt2++;
+             }
+         }
+     }
+ 
+     /** Perform two synchronized after each other on the same local object. */
+     @Benchmark
+     public void testInflatedSerialLockUnlockLocal() {
+         Object localObject = lockObject3Inflated;
+         for (int i = 0; i < innerCount; i++) {
+             synchronized (localObject) {
+                 dummyInt1++;
+             }
+             synchronized (localObject) {
+                 dummyInt2++;
+             }
+         }
+     }
+ 
+   /** Perform two synchronized after each other on the same object. */
+     @Benchmark
+     public void testInflatedSerialLockUnlock() {
+         for (int i = 0; i < innerCount; i++) {
+             synchronized (lockObject3Inflated) {
+                 dummyInt1++;
+             }
+             synchronized (lockObject3Inflated) {
+                 dummyInt2++;
+             }
+         }
+     }
+ 
+     /** Perform two synchronized after each other on the same object. */
+     @Benchmark
+     public void testInflatedMultipleSerialLockUnlock() {
+         for (int i = 0; i < innerCount; i++) {
+             synchronized (lockObject3Inflated) {
+                 dummyInt1++;
+             }
+             synchronized (lockObject4Inflated) {
+                 dummyInt2++;
+             }
+         }
+     }
+ 
+     /** Perform two synchronized after each other on the same object. */
+     @Benchmark
+     public void testInflatedMultipleRecursiveLockUnlock() {
+         for (int i = 0; i < innerCount; i++) {
+             synchronized (lockObject3Inflated) {
+                 dummyInt1++;
+                 synchronized (lockObject4Inflated) {
+                     dummyInt2++;
+                 }
+             }
+         }
+     }
+ 
+       /** Perform a recursive-only synchronized on a local object within a loop. */
+     @Benchmark
+     public void testInflatedRecursiveOnlyLockUnlockLocal() {
+         Object localObject = lockObject3Inflated;
+         synchronized (localObject) {
+             for (int i = 0; i < innerCount; i++) {
+                 synchronized (localObject) {
+                     dummyInt1++;
+                     dummyInt2++;
+                 }
+             }
+         }
+     }
+ 
+     /** Perform a recursive-only synchronized on an object within a loop. */
+     @Benchmark
+     public void testInflatedRecursiveOnlyLockUnlock() {
+         synchronized (lockObject3Inflated) {
+             for (int i = 0; i < innerCount; i++) {
+                 synchronized (lockObject3Inflated) {
+                     dummyInt1++;
+                     dummyInt2++;
+                 }
+             }
+         }
+     }
+ 
+     /** Perform a recursive-only synchronized on a local object within a loop. */
+     @Benchmark
+     public void testInflatedRecursiveLockUnlockLocal() {
+         Object localObject = lockObject3Inflated;
+         for (int i = 0; i < innerCount; i++) {
+             synchronized (localObject) {
+                 synchronized (localObject) {
+                     dummyInt1++;
+                     dummyInt2++;
+                 }
+             }
+         }
+     }
+ 
+     /** Perform a recursive-only synchronized on an object within a loop. */
+     @Benchmark
+     public void testInflatedRecursiveLockUnlock() {
+         for (int i = 0; i < innerCount; i++) {
+             synchronized (lockObject3Inflated) {
+                 synchronized (lockObject3Inflated) {
+                     dummyInt1++;
+                     dummyInt2++;
+                 }
+             }
+         }
+     }
+ 
      /**
       * Performs recursive synchronizations on the same local object.
       * <p/>
       * Result is 3628800
       */