PackedObject is an experimental feature in IBM J9 Virtual Machine. Goal(s) of Feature: Improve serialization and I/O of Java objects Allow direct access to “native” (off-heap) data Allow for explicit source-level representation of compact data-structure Intended Use: Provide an opportunity for feedback and experimentation Not meant for production support Not a committed language change

1. Marcel Mitran – STSM, Architect Java on System z
mmitran@ca.ibm.com
November 20th, 2012
IBM Java PackedObjects: An Overview
IBM Software Group: Java Technology Centre
© 2012 IBM Corporation

2. Important Disclaimers
THE INFORMATION CONTAINED IN THIS PRESENTATION IS PROVIDED FOR INFORMATIONAL PURPOSES
ONLY.
WHILST EFFORTS WERE MADE TO VERIFY THE COMPLETENESS AND ACCURACY OF THE INFORMATION
CONTAINED IN THIS PRESENTATION, IT IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED.
ALL PERFORMANCE DATA INCLUDED IN THIS PRESENTATION HAVE BEEN GATHERED IN A CONTROLLED
ENVIRONMENT. YOUR OWN TEST RESULTS MAY VARY BASED ON HARDWARE, SOFTWARE OR
INFRASTRUCTURE DIFFERENCES.
ALL DATA INCLUDED IN THIS PRESENTATION ARE MEANT TO BE USED ONLY AS A GUIDE.
IN ADDITION, THE INFORMATION CONTAINED IN THIS PRESENTATION IS BASED ON IBM’S CURRENT
PRODUCT PLANS AND STRATEGY, WHICH ARE SUBJECT TO CHANGE BY IBM, WITHOUT NOTICE.
IBM AND ITS AFFILIATED COMPANIES SHALL NOT BE RESPONSIBLE FOR ANY DAMAGES ARISING OUT OF
THE USE OF, OR OTHERWISE RELATED TO, THIS PRESENTATION OR ANY OTHER DOCUMENTATION.
NOTHING CONTAINED IN THIS PRESENTATION IS INTENDED TO, OR SHALL HAVE THE EFFECT OF:
- CREATING ANY WARRANT OR REPRESENTATION FROM IBM, ITS AFFILIATED COMPANIES OR ITS OR
THEIR SUPPLIERS AND/OR LICENSORS
2 © 2012 IBM Corporation

3. PackedObject Delivery and Intended Use
PackedObject is an experimental feature in IBM J9 Virtual Machine.
Goal(s) of Feature:
■ Improve serialization and I/O of Java objects
■ Allow direct access to “native” (off-heap) data
■ Allow for explicit source-level representation of compact data-structure
Intended Use:
■ Provide an opportunity for feedback and experimentation
– Not meant for production support
– Not a committed language change
3 © 2012 IBM Corporation

4. PackedObjects for IBM's Java
Features of today's Java work well in certain ...changing how Java data is represented and
Present data is accessed and used introduces
native l
scenarios, poorly in others...
new efficiencies into the Java language
●
Bloated Objects: Data headers and ●
Shared Headers & No References
references required to access and use data
stored outside of Java
●
No direct access to off-heap data: Java
Native Interface or Direct Byte Buffers
●
Direct access to native stored off-heap
required when accessing.
●
Redundant Data Copying: Copies of off-
heap data required to incorporate/act-on ●
Elimination of data copies
changes to source data
●
Suboptimal heap placement: Non-
adjacent placement of objects in memory ●
In-lined data allows for optimal caching
slows down serialization, garbage collection
4 © 2012 IBM Corporation

5. Speak to me in 'Java', I don't speak 'Native'
■ Java only speaks ‘Java’…
– Data typically must be copied/(de)serialized/marshalled onto/off Java heap
– Costly in path-length and footprint
5 © 2012 IBM Corporation

6. On-Heap PackedObjects Example
■ Allows controlled layout of storage of data structures on the Java heap
– Reduces footprint of data on Java heap
– No (de)serialization required
I/O
Native storage (20 bytes)
Java heap
JVM
6 © 2012 IBM Corporation

7. Off-Heap Packed Objects Example
■ Enable Java to talk directly to the native data structure
– Avoid overhead of data copy onto/off Java heap
– No (de)serialization required
I/O
Native storage (20 bytes)
Meta Data
JVM
Java heap
7 © 2012 IBM Corporation

8. Example: Distributed Computing High-Level Architecture
Communication between nodes
(RDMA, hyper-sockets, ORB, etc): Using Java packed objects, data can
● Data copy be moved between the
● (De)Serialization persistency and communication
layers without being copied or
(de)serialized onto/off the Java
Data persistency on each heap
node (DB, file-system,
etc):
● Data copy
● (De)serialization DB DB
JVM JVM
App. App.
Server Server
Node Node
8 © 2012 IBM Corporation

9. © 2012 IBM Corporation
Page 9
Example: Inter-language Communication
Java requires data
copies, marshalling and COBOL Java C/C++
serialization across
language boundaries foo(…){ goo(…){ loo(…){
… … …
goo(); loo(); }
} }
Java packed objects
avoids data copies, COBOL Java C/C++
marshaling and
serialization foo(…){ goo(…){ loo(…){
… … …
goo(); loo(); }
} }

10. PackedObjects 101
■ A new PackedObject type for the Java language, which allows for:
– Direct access of data located outside of the Java heap
– Contiguous allocation of all object's data (objects and arrays)
– Is not derived from Object, and hence dis-allows assignment and casting
– Special BoxingPackedObject is glue to reference a PackedObject from Object
java/lang/object java/lang/PackedObject
java/math/BigDecimal etc… java/lang/PackedArray etc…
java/lang/String java/lang/PackedString
java/lang/HashMapEntry java/lang/BoxedPackedObject java/lang/PackedHashMapEntry
■ Current Java Capabilities
– Current Java logic requires language interpreters and data copies for execution.
– PackedObjects eliminate data copies across the Java Native Interface and the
need to design and maintain Direct Byte Buffers
■ Using PackedObjects: annotation-based (or later a packed key word) above a class
definition is required to create a packed class. The class instances can be accessed and
modified identically to current Java objects
10 © 2012 IBM Corporation

11. Scope of Implementation
■ “@Packed” class annotation used to define a PackedObject class
■ “@Length” field annotation used to specify length of PackedObject arrays
Proposed Initial Rules
■ Packed types must directly subclass PackedObject
■ Packed inlining can only happen for field declarations which are primitives, PackedObjects or arrays of
PackedObjects
■ Fields made up of arrays must provide a length that is a compile time constant
■ Regular Java primitive types cannot be used to declare a PackedObject array. Boxed types for
primitive arrays must be used instead.
■ A field declaration cannot introduce a circular class dependency
■ When a PackedObject is instantiated, only the constructor for the top-level PackedObject is called
■ Local variable assignment and parameter passing of a PackedObject is copy-by-reference
■ BoxedPackedObject is used to box a PackedObject with an Object reference
■ Allocating a PackedObject using the 'new' keyword creates an on-heap PackedObject
■ Off-heap PackedObject creation is done using factory method provided in the class library
11 © 2012 IBM Corporation

12. Code Snippets
■ Packed class definition ■ On-Heap Packed Allocation
■ Off-heap Packed Allocation
12 © 2012 IBM Corporation

13. Functionality Changes
Current Java PackedObject
Data Field ■ Object fields limited to primitives or ■ When allocating a PackedObject, all
Allocation references to other objects; non- corresponding data fields get allocated
and Storage primitives must be initialized and copied simultaneously and packed into a single
into a format understood by Java. contiguous object (rather than
referenced).
■ Headers for child objects copied onto ■ No headers for child objects which all
Child objects
the Java heap when accessed. share global header on the
PackedObject.
Arrays ■ For arrays of objects each element in an ■ Arrays packed together contiguously
array has it's own header and a under one common header; array length
reference to it. The elements are not marked in PackedObject header. Full
contiguous in memory. access to elements in array and bounds
checking still performed.
Off-heap ■ Data can not be accessed or modified ■ Data that does not exist in Java can be
outside of the Java heap. Data must be accessed and modified directly by using
converted into a Java version and then the data's memory location. The Java
this copy can then be accessed and Virtual Machine takes care of the
manipulated. accessors and modifiers internally.
13 © 2012 IBM Corporation

14. Off Heap Benefit: Lowers Memory Footprint, increases performance
Before Native memory ●
Java requires objects to be in primitive form to be
Header accessed directly*
Header
Hea ●
If objects are not in primitive form, references and
Header Data der
Data copies required to access data; time-consuming
Data conversion process
Data
reference ●
When objects are graphed onto the heap, they
reference
reference
reference
are placed randomly and occupy more space than
is needed
He Java Heap
ad
HEADER
Da e er
Header ta C r d Memory bloat occurs due to data copies (data
●
Data Copy Hea
opy opy must be accessed and copied, including headers)
Header taC
Data Copy Da
*without the use of JNI or DBB
After ●
PackedObjects eliminate requirement for objects to
be in primitive form
●
PackedObjects can be accessed directly from source
without the redundant copying; no conversion
●
PackedObject allocates and packs all data fields
HEADER
(including other PackedObject and arrays) into a
Direct Access, No Copy
single well defined contiguous storage area
14 © 2012 IBM Corporation

15. Copyright and Trademarks
© IBM Corporation 2012. All Rights Reserved.
IBM, the IBM logo, and ibm.com are trademarks or registered trademarks of International
Business Machines Corp., and registered in many jurisdictions worldwide.
Other product and service names might be trademarks of IBM or other companies.
A current list of IBM trademarks is available on the Web – see the IBM “Copyright and
trademark information” page at URL: www.ibm.com/legal/copytrade.shtml
15 © 2012 IBM Corporation