Data Container Changes Part 2
Before the end of the year I wrote a blog post detailing some of the more recent changes that Infinispan introduced with the in memory data container. As was mentioned in the previous post we would be detailing some other new changes. If you poked around in our new schema after Beta 1 you may have spoiled the surprise for yourself.
With the upcoming 9.0 Beta 2, I am excited to announce that Infinispan will have support for entries being stored off heap, as in outside of the JVM heap. This has some interesting benefits and drawbacks, but we hope you can agree the benefits in many cases far outweigh the drawbacks. But before we get into that lets first see how you can configure your cache to utilize off heap.
New Configuration
The off heap configuration is another option under the new memory element that was discussed in the previous post. It is used in the same way that either OBJECT or BINARY is used. You can use either COUNT or MEMORY eviciton types, the example below shows the latter.
XML
DECLARATIVE
As you can see the configuration is almost identical to the other types of storage. The only real difference is the new address pointer argument, which will be explained below.
Requirements
Our off heap implementation supports all existing features of Infinispan. There are some limitations and drawbacks of using the feature. This section will describe these in further detail.
Serialization
Off Heap runs in essentially BINARY mode, which requires entries to be serialized into their byte[] forms. Thus all keys and entries must be Serializable or have provided Infinispan Externalizers.
Size
Currently a key and a value must be able to be stored in a byte[]. Therefore a key or value in serialized form cannot be more than just over 2 Gigabytes. This could be enhanced possibly at a later point, if the need arose. I hope you aren’t transferring this over your network though!
Implementation Details
Our off heap implementation uses the Java Unsafe to allocate memory outside of the Java heap. This data is stored as a bucket of linked list pointers, just like a standard Java HashMap. When an entry is added the key’s serialized byte[] is hashed and an appropriate offset is found in the bucket. Then the entry is added to the bucket as the first element or if an entry(ies) is present it is added to the rear of the linked list.
All of this data is protected by an array of ReadWriteLock instances. The number of address pointers is evenly divisible by the number of lock instances. The number of lock instances is how many cores your machines doubled and rounded to the nearest power of two. Thus each lock protects an equivalent amount of address spaces. This provides for good lock granularity and reads will not block each other but unfortunately writes will wait and block all reads.
If you are using a bounded off heap container either by count or memory this will create a backing LRU doubly linked list to keep track of which elements were accessed most recently and removes the least recently accessed element when there are too many present in the cache.
===
Memory Overhead
As with all cache implementations there is overhead required to store these entries. We have a fixed and variable overhead which scales with the amount of entries. I will detail these and briefly mention what they are used for.
Fixed overhead
As was mentioned there is a new address count parameter when configuring off heap. This value is used to determine how many linked list pointers are available. Normally you want to have more node pointers than you have entries in the cache, since then chances are you have one element in each linked list. This is very similar to the int argument constructor for HashMap. It is also rounded up to the nearest power of two. The big difference being that this off heap implementation will not resize. Thus your read/write times will be slower if you have a lot of collisions. The overhead of a pointer is 8 bytes, so for approximately one million pointers it will be 8 Megabytes of off heap.
Bounded off heap requires very little fixed memory, just 32 bytes for head/tail pointers and a counter and an additional Java lock object.
Variable overhead
Unfortunately to store your entries we may need to wrap them with some data. Thus for every entry you add to the cache we store an additional 25 bytes for each entry. This data is used for header information and also our linked list forward pointer.
Bounded off heap requires additional housekeeping for its LRU list nodes. Thus each entry adds an additional 36 bytes above the number above. It is larger due to requiring a doubly linked list and having to have pointers to and from the entry and eviction node.
Performance
The off heap container was designed with the intent that key lookups are quite fast. In general these should be about the same performance. However local reads and stream operations can be a little slower as there is an additional deserialization phase required.
Summary
We hope you all try out our new off heap feature! Please make sure to contact us if you have any feedback, find any bugs or have any questions! You can get in contact with us on our forum, issue tracker, or directly on IRC freenode channel Infinispan.
Get it, Use it, Ask us!
We’re hard at work on new features, improvements and fixes, so watch this space for more announcements!Please, download and test the latest release.
The source code is hosted on GitHub. If you need to report a bug or request a new feature, look for a similar one on our GitHub issues tracker. If you don’t find any, create a new issue.
If you have questions, are experiencing a bug or want advice on using Infinispan, you can use GitHub discussions. We will do our best to answer you as soon as we can.
The Infinispan community uses Zulip for real-time communications. Join us using either a web-browser or a dedicated application on the Infinispan chat.
William Burns
Will is a core Infinispan engineer working for Red Hat since 2013. He enjoys streaming data and writing reactive code.
