hbase-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Matt Corgan (JIRA)" <j...@apache.org>
Subject [jira] [Commented] (HBASE-10191) Move large arena storage off heap
Date Thu, 19 Dec 2013 01:17:08 GMT

    [ https://issues.apache.org/jira/browse/HBASE-10191?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13852436#comment-13852436

Matt Corgan commented on HBASE-10191:

Something to keep in mind is that GC pauses can be influenced as much or more by the number
of live objects as they can by the raw size of the heap.  32GB of block cache could be made
of only 1mm 32KB blocks.  This particular 32GB of memory may not stop the world for very long.
 It's all the small remaining objects that are keeping the garbage collector busy, and I bet
the biggest culprit here is the individual KeyValues in the memstores.

MemstoreLAB combines the backing arrays into big chunks to reduce heap fragmentation, but
there is still one object per KeyValue, and each object needs to be considered by the collector.
 A big heap has big memstores, which have lots of KeyValues - possibly far more than the 1mm
blocks in the block cache.  A big advantage of flattening the memstores into blocks of key
values is that you might be reducing ~500 KeyValues to a single block object.  This 500x reduction
in objects strikes me as a significant GC pause improvement that is independent from off-heap

Moving blocks off-heap and operating on them directly will be very cool.  DataBlockEncoders
should be able to read off-heap blocks similarly to how they do now, namely, copying only
the modified bytes from the previous cell into an array buffer.  Vladimir makes a good point
that it would be tough to match the scan performance of unencoded data, so that would need
some thinking.

> Move large arena storage off heap
> ---------------------------------
>                 Key: HBASE-10191
>                 URL: https://issues.apache.org/jira/browse/HBASE-10191
>             Project: HBase
>          Issue Type: Umbrella
>            Reporter: Andrew Purtell
> Even with the improved G1 GC in Java 7, Java processes that want to address large regions
of memory while also providing low high-percentile latencies continue to be challenged. Fundamentally,
a Java server process that has high data throughput and also tight latency SLAs will be stymied
by the fact that the JVM does not provide a fully concurrent collector. There is simply not
enough throughput to copy data during GC under safepoint (all application threads suspended)
within available time bounds. This is increasingly an issue for HBase users operating under
dual pressures: 1. tight response SLAs, 2. the increasing amount of RAM available in "commodity"
server configurations, because GC load is roughly proportional to heap size.
> We can address this using parallel strategies. We should talk with the Java platform
developer community about the possibility of a fully concurrent collector appearing in OpenJDK
somehow. Set aside the question of if this is too little too late, if one becomes available
the benefit will be immediate though subject to qualification for production, and transparent
in terms of code changes. However in the meantime we need an answer for Java versions already
in production. This requires we move the large arena allocations off heap, those being the
blockcache and memstore. On other JIRAs recently there has been related discussion about combining
the blockcache and memstore (HBASE-9399) and on flushing memstore into blockcache (HBASE-5311),
which is related work. We should build off heap allocation for memstore and blockcache, perhaps
a unified pool for both, and plumb through zero copy direct access to these allocations (via
direct buffers) through the read and write I/O paths. This may require the construction of
classes that provide object views over data contained within direct buffers. This is something
else we could talk with the Java platform developer community about - it could be possible
to provide language level object views over off heap memory, on heap objects could hold references
to objects backed by off heap memory but not vice versa, maybe facilitated by new intrinsics
in Unsafe. Again we need an answer for today also. We should investigate what existing libraries
may be available in this regard. Key will be avoiding marshalling/unmarshalling costs. At
most we should be copying primitives out of the direct buffers to register or stack locations
until finally copying data to construct protobuf Messages. A related issue there is HBASE-9794,
which proposes scatter-gather access to KeyValues when constructing RPC messages. We should
see how far we can get with that and also zero copy construction of protobuf Messages backed
by direct buffer allocations. Some amount of native code may be required.

This message was sent by Atlassian JIRA

View raw message