From eugen.rabii at gmail.com  Mon Feb 15 13:48:25 2016
From: eugen.rabii at gmail.com (Eugen Rabii)
Date: Mon, 15 Feb 2016 15:48:25 +0200
Subject: -XX:+UseCompressedOops -XX:ObjectAlignmentInBytes=16
Message-ID: <56C1D729.70500@gmail.com>

Hi,

This is probably not the best place to ask, but probably the only place 
I can figure out where I might get a good answer.
So, I'm trying to run some simple code, jdk-8.

         System.out.println(VMSupport.vmDetails());
         Integer i = new Integer(23);
         System.out.println(ClassLayout.parseInstance(i)
                 .toPrintable());

*The first attempt is to run it with compressed oops disabled and 
compressed klass also on 64-bit JVM.

*-XX:-UseCompressedOops -XX:-UseCompressedClassPointers
The output, pretty much expected is :

Running 64-bit HotSpot VM.
Objects are 8 bytes aligned.

java.lang.Integer object internals:
  OFFSET  SIZE  TYPE DESCRIPTION                    VALUE
       0     4       (object header)                01 00 00 00 
(00000001 00000000 00000000 00000000) (1)
       4     4       (object header)                00 00 00 00 
(00000000 00000000 00000000 00000000) (0)
       8     4       (object header)                48 33 36 97 
(01001000 00110011 00110110 10010111) (-1758055608)
      12     4       (object header)                01 00 00 00 
(00000001 00000000 00000000 00000000) (1)
      16     4   int Integer.value                  23
      20     4       (loss due to the next object alignment)
Instance size: 24 bytes (reported by Instrumentation API)
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

That makes sense : 8 bytes klass word + 8 bytes mark word + 4 bytes for 
the actual value and 4 for padding (to align on 8 bytes) = 24 bytes.

*
**The second attempt it to run it with **compressed oops enabled 
compressed klass also on 64-bit JVM.

*Again, the output is pretty much understandable :

Running 64-bit HotSpot VM.
Using compressed oop with 3-bit shift.
Using compressed klass with 3-bit shift.
Objects are 8 bytes aligned.

  OFFSET  SIZE  TYPE DESCRIPTION                    VALUE
       0     4       (object header)                01 00 00 00 
(00000001 00000000 00000000 00000000) (1)
       4     4       (object header)                00 00 00 00 
(00000000 00000000 00000000 00000000) (0)
       8     4       (object header)                f9 33 01 f8 
(11111001 00110011 00000001 11111000) (-134138887)
      12     4   int Dummy.i                        42
Instance size: 16 bytes (reported by Instrumentation API).

4 bytes compressed oop (klass word) + 8 bytes mark word + 4 bytes for 
the value + no space loss = 16 bytes.

The thing that does NOT make sense to me is this use-case:

*-XX:+UseCompressedOops -XX:+UseCompressedClassPointers 
-XX:ObjectAlignmentInBytes=16

*The output is this:

Running 64-bit HotSpot VM.
Using compressed oop with 4-bit shift.
Using compressed klass with 0x0000001000000000 base address and 0-bit shift.

I was really expecting to both be "4-bit shift". Why they are not?

Thank you,
Eugene.



*


*



From aleksey.shipilev at oracle.com  Mon Feb 15 14:01:32 2016
From: aleksey.shipilev at oracle.com (Aleksey Shipilev)
Date: Mon, 15 Feb 2016 17:01:32 +0300
Subject: -XX:+UseCompressedOops -XX:ObjectAlignmentInBytes=16
In-Reply-To: <56C1D729.70500@gmail.com>
References: <56C1D729.70500@gmail.com>
Message-ID: <56C1DA3C.8070307@oracle.com>

On 02/15/2016 04:48 PM, Eugen Rabii wrote:
> The thing that does NOT make sense to me is this use-case:
> 
> *-XX:+UseCompressedOops -XX:+UseCompressedClassPointers
> -XX:ObjectAlignmentInBytes=16
> 
> *The output is this:
> 
> Running 64-bit HotSpot VM.
> Using compressed oop with 4-bit shift.
> Using compressed klass with 0x0000001000000000 base address and 0-bit
> shift.
> 
> I was really expecting to both be "4-bit shift". Why they are not?

Indeed, this is not the forum for these questions. Ask at StackOverflow,
the answer is quite simple.

Cheers,
-Aleksey