db-derby-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Rick Hillegas (JIRA)" <j...@apache.org>
Subject [jira] [Commented] (DERBY-4437) Concurrent inserts into table with identity column perform poorly
Date Tue, 28 Jun 2011 16:51:17 GMT

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

Rick Hillegas commented on DERBY-4437:
--------------------------------------

No further opinions have surfaced. I propose to make the following changes:

o Increase the size of the default preallocated range from 5 to 20 to match the behavior of
other databases.

o Change the default preallocator so that setting derby.language.sequence.preallocator to
a positive integer will cause that number to be the size of the default preallocated ranges
for both sequences and identity columns.

o Backport the accumulated work on this issue to 10.8.

o Supply a release note which describes the following behavior changes for 10.8.2:

1) Throughput/concurrency of applications with identity columns should increase.

2) Sequences and identity columns will leak up to 20 unused values apiece on abnormal shutdown.

3) Applications can plug the leaks by performing orderly database shutdowns.

4) Applications can revert to the old identity behavior by setting derby.language.sequence.preallocator=1.
This will also reduce the concurrency of sequences.

5) Applications can change the concurrency and leakage behavior of all sequences and identities
by setting derby.language.sequence.preallocator to some other positive number.

6) Applications can further customize the concurrency (and leakage size) of individual sequences
and identities by setting derby.language.sequence.preallocator equal to the name of a user-written
class which implements org.apache.derby.catalog.SequencePreallocator.

If this does not sound like a good plan, please let me know. Thanks.


> Concurrent inserts into table with identity column perform poorly
> -----------------------------------------------------------------
>
>                 Key: DERBY-4437
>                 URL: https://issues.apache.org/jira/browse/DERBY-4437
>             Project: Derby
>          Issue Type: Improvement
>          Components: SQL
>    Affects Versions: 10.5.3.0
>            Reporter: Knut Anders Hatlen
>            Assignee: Rick Hillegas
>         Attachments: D4437PerfTest.java, D4437PerfTest2.java, Experiments_4437.html,
derby-4437-01-aj-allTestsPass.diff, derby-4437-02-ac-alterTable-bulkImport-deferredInsert.diff,
derby-4437-03-aa-upgradeTest.diff, derby-4437-04-aa-reclaimUnusedValuesOnShutdown.diff, derby-4437-05-aa-pluggablePreallocation.diff,
derby-4437-06-aa-selfTuning.diff, insertperf.png, insertperf2.png, prealloc.png
>
>
> I have a multi-threaded application which is very insert-intensive. I've noticed that
it sometimes can come into a state where it slows down considerably and basically becomes
single-threaded. This is especially harmful on modern multi-core machines since most of the
available resources are left idle.
> The problematic tables contain identity columns, and here's my understanding of what
happens:
> 1) Identity columns are generated from a counter that's stored in a row in SYS.SYSCOLUMNS.
During normal operation, the counter is maintained in a nested transaction within the transaction
that performs the insert. This allows the nested transaction to commit the changes to SYS.SYSCOLUMN
separately from the main transaction, and the exclusive lock that it needs to obtain on the
row holding the counter, can be releases after a relatively short time. Concurrent transactions
can therefore insert into the same table at the same time, without needing to wait for the
others to commit or abort.
> 2) However, if the nested transaction cannot lock the row in SYS.SYSCOLUMNS immediately,
it will give up and retry the operation in the main transaction. This prevents self-deadlocks
in the case where the main transaction already owns a lock on SYS.SYSCOLUMNS. Unfortunately,
this also increases the time the row is locked, since the exclusive lock cannot be released
until the main transaction commits. So as soon as there is one lock collision, the waiting
transaction changes to a locking mode that increases the chances of others having to wait,
which seems to result in all insert threads having to obtain the SYSCOLUMNS locks in the main
transaction. The end result is that only one of the insert threads can execute at any given
time as long as the application is in this state.

--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira

        

Mime
View raw message