jackrabbit-oak-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Tomek Rękawek (JIRA) <j...@apache.org>
Subject [jira] [Commented] (OAK-4882) Bottleneck in the asynchronous persistent cache
Date Tue, 25 Oct 2016 13:52:58 GMT

    [ https://issues.apache.org/jira/browse/OAK-4882?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15605371#comment-15605371
] 

Tomek Rękawek commented on OAK-4882:
------------------------------------

[~mmarth], the problem here is as follows:

a) in case of a high load, there is a lot of persistent cache updates,
b) the H2 MVStore used for the persistence, sometimes need to maintain its files,
c) the maintenance takes place in the thread invoking {{put()}} method. The maintenance process
blocks all the other threads from putting anything into the cache (so they have to wait until
maintenance is done) and basically makes the impression that the whole instance hangs.

That's why the OAK-2761 introduced mechanism to {{put()}} entries to the MVStore asynchronously,
using some queue. The question is what to do if the queue is full. Should we:

1) block the caller - however, this will lead to (c) case again, as after some time of high
load the queue will be full again,
2) remove the oldest or drop the most recent {{put()}} entries - this option has disadvantage
described in your post
3) ?

> Bottleneck in the asynchronous persistent cache
> -----------------------------------------------
>
>                 Key: OAK-4882
>                 URL: https://issues.apache.org/jira/browse/OAK-4882
>             Project: Jackrabbit Oak
>          Issue Type: Bug
>          Components: cache, documentmk
>    Affects Versions: 1.5.10, 1.4.8
>            Reporter: Tomek Rękawek
>            Assignee: Tomek Rękawek
>             Fix For: 1.6
>
>
> The class responsible for accepting new cache operations which will be handled asynchronously
is [CacheActionDispatcher|https://github.com/apache/jackrabbit-oak/blob/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/document/persistentCache/async/CacheActionDispatcher.java].
In case of a high load, when the queue is full (=1024 entries), the [add()|https://github.com/apache/jackrabbit-oak/blob/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/document/persistentCache/async/CacheActionDispatcher.java#L86]
method removes the oldest 256 entries. However, we can't afford losing the updates (as it
may result in having stale entries in the cache), so all the removed entries are compacted
into one big invalidate action.
> The compaction action ([CacheActionDispatcher#cleanTheQueue|https://github.com/apache/jackrabbit-oak/blob/trunk/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/document/persistentCache/async/CacheActionDispatcher.java#L97])
still holds the lock taken in add() method, so threads which tries to add something to the
queue have to wait until cleanTheQueue() ends.
> Maybe we can optimise the CacheActionDispatcher#add->cleanTheQueue part, so it won't
hold the lock for the whole time.



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)

Mime
View raw message