You are viewing a plain text version of this content. The canonical link for it is here.
Posted to derby-dev@db.apache.org by "Olav Sandstaa (JIRA)" <ji...@apache.org> on 2006/10/31 11:12:16 UTC
[jira] Created: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Change file option for syncing log file to disk from rws to rwd
---------------------------------------------------------------
Key: DERBY-2020
URL: http://issues.apache.org/jira/browse/DERBY-2020
Project: Derby
Issue Type: Improvement
Components: Performance, Store
Affects Versions: 10.3.0.0
Reporter: Olav Sandstaa
For writing the transaction log to disk Derby uses a
RandomAccessFile. If it is supported by the JVM, the log files are
opened in "rws" mode making the file system take care of syncing
writes to disk. "rws" mode will ensure that both the data and the file
meta-data is updated for every write to the file. On some operating
systems (e.g. Solaris) this leads to two write operation to the disk
for every write issued by Derby. This is limiting the throughput of
update intensive applications. If we could change the file mode to
"rwd" this could reduce the number of updates to the disk.
I have run some simple tests where I have changed mode from "rws" to
"rwd" for the Derby log file. When running a small numbers of
concurrent client threads the throughput is almost doubled and the
response time is almost halved. I will attach some graphs that show
this when running a given number of concurrent "tpc-b" like clients. These
graphs show the throughput when running with "rws" and "rwd" mode when the
disk's write cache has been enabled and disabled.
I am creating this Jira to have a place where we can collect
information about issues both for and against changing the default
mode for writing to log files.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
Re: [jira] Commented: (DERBY-2020) Change file option for syncing log file to disk from rws to rwd
Posted by Myrna van Lunteren <m....@gmail.com>.
On 6/13/07, Olav Sandstaa (JIRA) <ji...@apache.org> wrote:
>
> [ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12504155 ]
>
> Olav Sandstaa commented on DERBY-2020:
> --------------------------------------
>
> Thanks a lot for writing the release note, Myrna.
>
> I think the release note look very good and I have only some minor comments:
>
> 1. If the VM supports "rws" it also supports "rwd" mode. So there are no reverting back from "rwd" to "rws". The only case where Derby revert back from using "rwd" is due to a JVM bug, and then Derby will revert back to use "rw" mode (since the bug is also present when running with "rws"). I propose to change the last sentence in "Rationale for Change" from:
>
> "Because not all JVMs support this mechanism, Derby will check if it can use this mechanism and if not, it will revert back to using the "rws" and print an appropriate message indicating same in derby.log"
>
> to
>
> "Some JVMs have a bug in the support for "rws" and "rwd" mode. Derby will check for this bug, and if it is detected, Derby will revert back to using "rw" mode and print an appropriate message indicating this in derby.log".
>
> 2. For the same reason I propose that the second sentence in the "Application Changes required" is changed from:
>
> "If not, a message will be printed to derby.log:"
>
> to
>
> "If Derby detects that your JVM has a bug in the support for "rwd", a message will be printed to derby.log"
>
> (as it is written now it seems like this sentence would be written to derby.log every time Derby does not use "rwd" mode. This is no correct. For JVMs older than 1.4.2 "rwd" is not supported, but Derby will not write anything about this to the derby.log)
>
> 3. There is a "the the" typo in the second last sentence in the "Rationale for Change" section.
>
> Let me know if you want me to upload a new version of the release note or if you incorporate this.
Thx for looking at this...If you can upload a new version it I'd prefer it :-)
But if you haven't done so by the time it gets lunch time in
California I'll take care of it this afternoon and resolve the issue.
Myrna
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12482754 ]
Olav Sandstaa commented on DERBY-2020:
--------------------------------------
Suresh and Mike,
Thanks for the comments.
I agree that Derby should not have to do extra work to handle
something that is a JVM bug. Still, since there already is code to
handle this situation I think it is worth to maintain this
functionality given that it does not affect the normal operation of
Derby. And I think Derby running with "rwd" mode for these bug vms
that do not sync is much more likely to result in a non-recoverable
database when running on a disk that has the write cache enabled. With
the write cache enabled on the disk, the data will in most situations
be written to disk even when there is a system crash or power failure
(but with no guarantee). With the data only being written to the file
system cache and no syncing to disk there is a much longer time period
where you do not have the log synced to disk.
I will make a proposal for a fix for how to handle this JVM bug based
on opening a file on the log device (I agree with Suresh that using
the tmp device is not a good idea).
To answer Suresh's second question. Yes, after crash that occurs
while updating a file in "rwd" mode everything that is related to
the content of the file and being able to read the file must be
updated on disk. This should include the length of the file.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Daniel John Debrunner (JIRA)" <ji...@apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-2020?page=comments#action_12445922 ]
Daniel John Debrunner commented on DERBY-2020:
----------------------------------------------
I think it's important to get some resolution of the specified behaviour of rwd & rws in the Java specifications. Investiating the various OSes is interesting but Derby is written against the Java specs. Maybe a bug could be entered at Sun?
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: http://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Store, Performance
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12480411 ]
Olav Sandstaa commented on DERBY-2020:
--------------------------------------
Thanks for the comments, Knut Anders. I will go through the comments and update the references to "rws".
As for a solution to the JVM bug in some VMs on MAC, I was not aware
about the difference in how this bug(s) manifested itself when opening
in rws and rwd mode. I have read to comments in the workaround and in
DERBY-1. If I understand it correctly we need at least open a file
once in rws mode in order to decide if we have this bug. Right now
this is done the first time LogToFile.openLogFileInWriteMode() is
called. I want to change this to always use rwd instead of rws, but
this will not detect this problem. Some possible solutions could be:
1. The first time LogToFile.openLogFileInWriteMode() is called, try to
open the file in rws mode to see if we get the exception. If no
exception is thrown, re-open the file in rwd mode. If an exception
is thrown revert to use rw mode.
2. Move this check to DirStorageFactory4.supportsRws(). Today, this
function will return true for all JVMs 1.4.2 or newer. I think it
might be more logical to have a check in this method to determine
if there are any issues that should prevent us from using rws or
rwd. For instance, the first time this method was called we could:
1. Create a file in Derby's tmp directory using "rw" mode.
2. Close it.
3. Reopen the file in rws mode.
4. If an exception is thrown, then make the method return false
(ie. this JVM does not support rws/rwd).
I think alternative 2 is a cleaner approach. Since I do not have a
machine running Mac OS I will have no way to actually test that this
works. I will make a patch for it hoping that someone will test it
out.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Suresh Thalamati (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12491013 ]
Suresh Thalamati commented on DERBY-2020:
-----------------------------------------
Thanks for addressing my comments , Olav. The latest patch looks good.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Olav Sandstaa updated DERBY-2020:
---------------------------------
Derby Info: [Patch Available]
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12490368 ]
Olav Sandstaa commented on DERBY-2020:
--------------------------------------
Knut Anders, thanks for committing the patch and particularly for running a test on a buggy JVM to verify that the the buq was detected and that the workaround was triggered.
I will submit a new patch shortly which do the changing of mode for opening of log files.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Myrna van Lunteren (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Myrna van Lunteren updated DERBY-2020:
--------------------------------------
Derby Info: [Release Note Needed]
marking release note needed.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12480050 ]
Olav Sandstaa commented on DERBY-2020:
--------------------------------------
I have discussed this change with someone working on this part of Java
within Sun. The feedback I have received is that the following text in
the JavaDoc for the RandomAccessFile constructor (see
http://java.sun.com/j2se/1.4.2/docs/api/java/io/RandomAccessFile.html):
"If the file resides on a local storage device then when an
invocation of a method of this class returns it is guaranteed that
all changes made to the file by that invocation will have been
written to that device. This is useful for ensuring that critical
information is not lost in the event of a system crash. If the file
does not reside on a local device then no such guarantee is made."
applies to both "rws" and "rwd" mode (as the text says). So with
regards to the content of the file and the possibility to read the
data from the file after a system crash, these two options should have
identical behavior and give identical guarantees. The only
optimizations that "rwd" is allowed to do is to not update meta-data
that are not critical for reading the file data. If data that has been
appended to a file is lost in a crash, the "critical information is
not lost" requirement is broken, and the implementation is
non-conforming to the spec.
This change gives a large performance benefit on some operating
systems. As far as I can see, this should be a safe change to Derby and
I propose this patch being reviewed and committed.
I have run derbyall and the JUnit test suite, and as expected I did
not see any problems.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-2020?page=all ]
Olav Sandstaa updated DERBY-2020:
---------------------------------
Attachment: rwd.diff
rwd.stat
This patch changes the sync mode of the log files from "rws" to "rwd".
The purpose is to let other people test this change out to see if it has any impact on performance or any issues with regards to recoverability after failure. The patch is NOT intended for inclusion in Derby (yet).
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: http://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Mike Matrigali (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Mike Matrigali updated DERBY-2020:
----------------------------------
I have been convinced by Olav's recent posting that it is ok to use rwd - I won't block this change, though I continue to think that the wording in the spec could be better. I agree that is likely on most if not all JVM's where we are doing the extra I/O in rws
mode that it is unnecessary synchronous I/O. It does make me slightly uneasy that we are changing this mode for no reason on some jvm's for no performance benefit (ie. on windows machines we didn't see any performance difference between the
two modes so choose the safer mode).
I do think we should make sure 10.3 documentation reflects this change in behavior as I still think the wording of the JVM spec is inexact. I think we should document somewhere exactly what we are expecting from the JVM interfaces to guarantee a recoverable DB. We have to answer this question enough when explaining why we go slower than other DB's that don't sync at all, we might as well be able to point to the documentation and to a release note for this change.
On the MAC/FreeBSD issue, I am not sure we should go out of our way to recognize the problem. The previous workaround was put in because it came for "free", ie. did not penalize all the JVM's for buggy implementations - and the system would not
even boot without the workaround. If after this change the db
boots on these buggy JVM's but does not sync properly - I am not sure it is worth fixing. This is not much different than today's situation where you boot derby on a machine where you have the "write-sync" option disabled on the device (a default setting on many configurations). Best would be if we could code a solution that only caused extra work on the buggy JVM's.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Suresh Thalamati (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12480516 ]
Suresh Thalamati commented on DERBY-2020:
-----------------------------------------
Olav,
Thanks for finding more details about rws/rwd.
1) I would avoid using a temp file to check if rws/rwd is correctly
working or not. On some OS , temp files use a differ file system.
Derby can be configured to use a different temp directory than the default
location, which can potentially be on a different file system.
I belive the check should be on log directory , where the log actually
will be stored.
2) If you use "rwd" to open a file and crash while appending.
On recovery does it give correct length of the file ?
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Myrna van Lunteren (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Myrna van Lunteren updated DERBY-2020:
--------------------------------------
Attachment: releaseNote.html
No release note appeard forthcoming so I took a stab at it...Review, anyone?
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, releaseNote.html, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Knut Anders Hatlen (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12480432 ]
Knut Anders Hatlen commented on DERBY-2020:
-------------------------------------------
I agree that alternative 2 sounds best.
I'll try to explain the details of the JVM bug as I understood it after logging it as a bug against FreeBSD's Java (http://www.freebsd.org/cgi/query-pr.cgi?pr=java/102888).
If the JVM is compiled on a system which has not defined both O_SYNC and O_DSYNC (which is the case for FreeBSD, and probably also other BSDs like Mac OS X), the JVM sources define O_SYNC as 0x0800 and O_DSYNC as 0x2000. As far as I know, the bit in 0x2000 has no meaning to the open() system call in BSD, so "rwd" mode will be identical to "rw" mode. However, 0x0800 is identical to the value of O_EXCL, which means "error if create and file exists". Therefore, "rws" mode is interpreted as "open in rw mode and fail if the file exists".
So to detect the JVM bug, you would have to
1) Create a file (for instance with File.createFile() or File.createTempFile()).
2) Open that file in rws mode and see if you get a FileNotFoundException.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Myrna van Lunteren (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Myrna van Lunteren updated DERBY-2020:
--------------------------------------
Derby Info: [Existing Application Impact, Release Note Needed] (was: [Existing Application Impact])
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, releaseNote.html, releaseNote.html, releaseNote.html, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12483962 ]
Olav Sandstaa commented on DERBY-2020:
--------------------------------------
Hi Knut Anders,
Thanks for the review comments - and thanks for changing your mind about your first comment - given that I do not have any way to verify this I would happily have made any changes you suggested :-)
I agree with your second comment and will post an updated patch.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Resolved: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Myrna van Lunteren (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Myrna van Lunteren resolved DERBY-2020.
---------------------------------------
Resolution: Fixed
Derby Info: [Existing Application Impact] (was: [Release Note Needed])
release note was attached. I think this issue is now complete.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, releaseNote.html, releaseNote.html, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-2020?page=all ]
Olav Sandstaa updated DERBY-2020:
---------------------------------
Attachment: no-disk-cache.png
disk-cache.png
These graphs shows the throughput when running a specified numbers of clients each running "tpc-b" like transaction (3 updates, 1 insert, 1 select) against Derby. Each graphs contains the throughput number when the log files are opened with "rws" and "rwd". The first graph is run on a system where the disk's write cache has been disabled. In the second graph the disk's write cache has been enabled.
The graphs are produced on dual AMD Opteron machine running Solaris 10 and Sun JDK 1.5.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: http://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12489241 ]
Olav Sandstaa commented on DERBY-2020:
--------------------------------------
Thanks for comments, Suresh.
1) The reason for creating a new file "rwstest.tmp" was due to I wanted to be able to have this check done early and in a single place during the boot of the log system. At the place I decided to add the test the boot code does not know the name of the first log file and a log file does not even have to exist at that time. I did not want to have to scan the log directory to be able to find an existing log file that could be used for testing.
2) I think your comment about read only databases are very valid. By reading the code it seems like my new code could end up throwing exceptions that would not be handled properly and lead to failed start-ups for read-only databases.
I will address both of these issues by moving the testing for this JVM bug into the method LogToFile.openLogFileInWriteMode(). At this point Derby both know the name of the log file to be opened first and this code will not be called for the readonly db cases. The only "drawback" by having this code in this method is that there will be need for some extra logic to ensure that this check is only run once.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Olav Sandstaa updated DERBY-2020:
---------------------------------
Attachment: jvmsyncbug_v2.stat
jvmsyncbug_v2.diff
Updated patch for how to detect "JVM bug for rws/rwd mode" (see DERBY-1) based on the second comment from Knut Anders. The only change to in this version of the patch is that it now only catches the FileNotFoundException instead of catching all IOExpections.
I have run derbyall and the JUnit suite without any errors with JDK5 on Solaris 10.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Mike Matrigali (JIRA)" <ji...@apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-2020?page=all ]
Mike Matrigali updated DERBY-2020:
----------------------------------
I am also uncomfortable making this change across all jvm/OS without some better contract from the java spec on what
exactly the options mean. The current option was picked as it seemed "safest" way to guarantee log write to disk. On some OS's using the RWS flag results in only a single I/O per write to a preallocated log file. The key
issue is what is "metadata". Is it timestamps for modify times in which case derby does not care, or is it data about file
allocation which if not synced may render recovery of the log file after a system crash inconsistent after derby thinks it has
guaranteed I/O to disk.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: http://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Mike Matrigali (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Mike Matrigali updated DERBY-2020:
----------------------------------
i think a release note would be appropriate to let users know in what environments they can expect to see a benefit from 10.3 with respect to this change. For instance I don't think it affects windows and am pretty sure it helps sun. Not sure about other OS's. Also maybe something about what kind of app will see benefit.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Olav Sandstaa updated DERBY-2020:
---------------------------------
Derby Info: [Patch Available]
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Kristian Waagan (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Kristian Waagan updated DERBY-2020:
-----------------------------------
Derby Info: (was: [Patch Available])
Fix Version/s: 10.3.0.0
Committed 'rwd_v2.diff" to trunk with revision 535270.
I believe all required work has been completed for this issue, but I will await confirmation before I (or someone else) set it to "Fixed".
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12494100 ]
Olav Sandstaa commented on DERBY-2020:
--------------------------------------
Thanks for committing the patch, Kristian.
With regards to Craigs concern about introducing a problem on Mac OS X, the answer is that I am not aware of anyone who have tested the patch on OS X. But I tried to take precausion for this problem by first submitting a patch that should hopefully be able to detect this problem on buggy JVMs on OS X and FreeBSD and do a workaround by using "rw" instead of "rwd". But since I did not have access to any of these OSs I was not able to test it. Knut Anders tested the workaround for this bug on FreeBSD, but I have not heard anybody having the itch to test it on OS X yet. It would be great if anybody did - and if the JVM bug is detected on OS X you should see a statement about this in the derby.log.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Craig Russell (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12494073 ]
Craig Russell commented on DERBY-2020:
--------------------------------------
IIRC, the reason this was changed just a few years ago from rwd to rws is as a workaround for a nasty Apple MacOSX bug in which you could not create a database and immediately access it.
Has anyone built and run Derby on OSX with this patch applied to make sure we don't regress all the OSX users?
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Suresh Thalamati (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12486434 ]
Suresh Thalamati commented on DERBY-2020:
-----------------------------------------
Thanks for working on this issue Olav. your latest patch jvmsyncbug_v2.diff
looks good. couple of minor comments:
1) One thing that puzzled me is why are you creating a new
file "rwtest.tmp" ? why can not the test be done on the current log file
itself, by opening the log file in "rws" mode and then closing, before
it is opened in the appropriate mode. That way you can avoid a creating a
new file and deleting it.
2)
And Also, there are these weird read only db state scenarios. For example
if you attempt to create a file when the db is made read readonly by putting it
in a jar, derby is ok as long as there are no transactions pending. If there
any pending transaction we may not catch it any more, because jvmsyncError() method
attempting to create a "rwtest.tmp" file very early, it may fail immediately on
log factory boot and decide all is well to treat the database as READONLY. But
it will be a inconsistent one.
I think derby tests suites has a readonly test, but i am not sure it covers pending
transaction error case.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Myrna van Lunteren (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12502474 ]
Myrna van Lunteren commented on DERBY-2020:
-------------------------------------------
On second thought, maybe this needs a release note?
Could there possibly be anything a user needs to do to accomodate this?
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-2020?page=comments#action_12446971 ]
Olav Sandstaa commented on DERBY-2020:
--------------------------------------
I agree that it would be good to get a clarification of this into the specification. I will try to discuss this with someone working in Sun's Java team and possibly enter a bug or a request for improvement for this. Still, I think it is good to have some data from different OSes on how this affect the performance in order to decide if this is worth the effort to try to change how the log is written.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: http://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-2020?page=comments#action_12445865 ]
Olav Sandstaa commented on DERBY-2020:
--------------------------------------
A discussion related to this issue has taken place in the following mail thread:
http://www.nabble.com/Options-for-syncing-of-log-to-disk-tf2188615.html
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: http://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Myrna van Lunteren (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Myrna van Lunteren updated DERBY-2020:
--------------------------------------
Attachment: releaseNote.html
scrubbed releasenote
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, releaseNote.html, releaseNote.html, releaseNote.html, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Assigned: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Olav Sandstaa reassigned DERBY-2020:
------------------------------------
Assignee: Olav Sandstaa
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Olav Sandstaa updated DERBY-2020:
---------------------------------
Attachment: rwd_pre.stat
rwd_pre.diff
This patch (rwd_pre.diff) contains changes in comments and a method name that could be committed independently and in advance of the actual change of file mode for log files. The main changes are:
1. Rename the method called supportsRws() to supportWriteSync() in WritableStorageFactory and all of its implementation.
2. Fixed code comments referring to "rws" to also include "rwd" so that the comments also will be valid if rwd is used.
The patch does not include any functional changes. The purpose of submitting this separately is to keep the size of the actual patch that changes the file mode small.
Derbyall and the Junit suite have been run with zero failures.
The patch is ready for review and commit.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12504155 ]
Olav Sandstaa commented on DERBY-2020:
--------------------------------------
Thanks a lot for writing the release note, Myrna.
I think the release note look very good and I have only some minor comments:
1. If the VM supports "rws" it also supports "rwd" mode. So there are no reverting back from "rwd" to "rws". The only case where Derby revert back from using "rwd" is due to a JVM bug, and then Derby will revert back to use "rw" mode (since the bug is also present when running with "rws"). I propose to change the last sentence in "Rationale for Change" from:
"Because not all JVMs support this mechanism, Derby will check if it can use this mechanism and if not, it will revert back to using the "rws" and print an appropriate message indicating same in derby.log"
to
"Some JVMs have a bug in the support for "rws" and "rwd" mode. Derby will check for this bug, and if it is detected, Derby will revert back to using "rw" mode and print an appropriate message indicating this in derby.log".
2. For the same reason I propose that the second sentence in the "Application Changes required" is changed from:
"If not, a message will be printed to derby.log:"
to
"If Derby detects that your JVM has a bug in the support for "rwd", a message will be printed to derby.log"
(as it is written now it seems like this sentence would be written to derby.log every time Derby does not use "rwd" mode. This is no correct. For JVMs older than 1.4.2 "rwd" is not supported, but Derby will not write anything about this to the derby.log)
3. There is a "the the" typo in the second last sentence in the "Rationale for Change" section.
Let me know if you want me to upload a new version of the release note or if you incorporate this.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, releaseNote.html, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Knut Anders Hatlen (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12480090 ]
Knut Anders Hatlen commented on DERBY-2020:
-------------------------------------------
Thanks for investigating this issue, Olav. It is my understanding too that the javadoc in RandomAccessFile gives the needed guarantee.
Some comments to the patch:
- LogToFile mentions rws in some comments (for instance, "reopen the file in rws mode"). Should they be updated?
- openLogFileInWriteMode() has a workaround for a JVM bug when opening in rws mode (DERBY-1). The exception it catches is only thrown for rws, but the JVMs with this bug also have a buggy rwd implementation. The bug in rwd only manifests itself by not syncing, so the workaround won't work anymore (Derby will appear to work, and even be extremely fast on updates, but the database might not be recoverable after a crash). If we change the file mode to rwd, I think we have to update the workaround so that it still detects the JVM bug. Perhaps we could detect it by opening a file in rws mode when booting the database, and if it throws FileNotFoundException we enable the workaround?
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Olav Sandstaa updated DERBY-2020:
---------------------------------
Attachment: jvmsyncbug.stat
jvmsyncbug.diff
This patch (jvmsyncbug.diff) is a proposal for how we can handle the JVM bug that have been reported for some JVMs on Mac OS and FreeBSD. The main change is to handle this bug as part of the "error handling" after failing to open a log file in "rws" mode to explicitely checking if this error is present. The purpose of this change is to be able to handle problems when the log file is opened in "rws" and "rwd" mode (the current code in Derby only handles failures for the "rws" mode).
The patch do the following during booting of Derby's logging module to detect if the JVM bug is present
1. Creates a file in the log directory using "rw" mode - this should succeed on all JVMs
2. Re-opens the same file using "rws" mode. If this operation failes, the JVM bug is present. An error message is written to the derby log file (not THE LOG but derby.log).
If the JVM bug is present, Derby changes from using synchronized writes for the log to use normal writes followed by an explicite sync. The patch also removes the current code for handling this problem.
The patch does NOT include the proposed change from using "rws" to "rwd" mode.
I do not have strong opinions about whether Derby should handle this JVM bug or not. I have run derbyall and the JUnit test suite on JDK 5 on Solaris 10. I have not run it with any of the JVMs with the reported JVM bug (I do no longer have a FreeBSD machine - and I have never had a Mac).
Feel free to review and commit the patch if you think this is a good thing to have in Derby. If you think this code for handling a JVM specific error should not be in the code please say so.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Knut Anders Hatlen (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12483911 ]
Knut Anders Hatlen commented on DERBY-2020:
-------------------------------------------
Hi Olav,
I think your approach of moving the checking into a separate method run on boot is good. However, I see two problems with checkJvmSyncError().
1) By opening the temporary file in rw mode first, you will make sure it exists. When the file exists, opening it in rws mode doesn't fail, so the bug will go undetected.
2) When opening the temp file in rws mode, you check for IOException. The bug will always cause a FileNotFoundException, so it's better to check for that exact exception so that other (unexpected) IOExceptions are not swallowed/misinterpreted.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Myrna van Lunteren (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12501657 ]
Myrna van Lunteren commented on DERBY-2020:
-------------------------------------------
I've tested 10.3 on Mac (OSX 10.4) for a bit, and all seems to work fine.
(except of running out of memory with suites.All, which is not unique to mac).
But then, the jvm version I'm running with does not have the JVM bug anymore.
So I can't verify the workaround is still in place.
I think it is ok to set this one to fixed.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Closed: (DERBY-2020) Change file option for syncing log file
to disk from rws to rwd
Posted by "Myrna van Lunteren (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Myrna van Lunteren closed DERBY-2020.
-------------------------------------
Resolution: Fixed
Derby Info: [Existing Application Impact, Release Note Needed] (was: [Release Note Needed, Existing Application Impact])
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, releaseNote.html, releaseNote.html, releaseNote.html, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Myrna van Lunteren (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Myrna van Lunteren updated DERBY-2020:
--------------------------------------
Attachment: releaseNote.html
I incorporated the changes. I also added a reference to the jdk 1.4.2 version and up to indicate earlier jvm versions do not support this.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, releaseNote.html, releaseNote.html, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Knut Anders Hatlen (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Knut Anders Hatlen updated DERBY-2020:
--------------------------------------
Derby Info: (was: [Patch Available])
Thanks Olav! I committed jvmsyncbug_v3.diff with revision 530807.
I ran derbyall and suites.All successfully on Solaris 10 and verified manually that the patch didn't cause problems for read-only databases.
I also logged on to people.apache.org (which happens to run FreeBSD and a buggy 1.5 JVM) where I created a database and ran some simple queries with ij. No problems there, and derby.log showed this message which confirmed that the workaround had been triggered:
------------ BEGIN ERROR MESSAGE -------------
LogToFile.checkJvmSyncError: Your JVM seems to have a problem with implicit syncing of log files. Will use explicit syncing instead.
------------ END ERROR MESSAGE -------------
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Knut Anders Hatlen (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Knut Anders Hatlen updated DERBY-2020:
--------------------------------------
Derby Info: (was: [Patch Available])
rwd_pre.diff looks good. Committed revision 532635.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Olav Sandstaa updated DERBY-2020:
---------------------------------
Attachment: jvmsyncbug_v3.stat
jvmsyncbug_v3.diff
This patch includes changes based on comments from Suresh. The check for the JVM bug is now done in openLogFileInWriteMode. The test will be done on the log file that is going to be used. The check does first open the file in "rw" mode to ensure that the file exists and then re-opens it in "rws" mode. If a FileNotFoundExceptions is thrown, Derby will switch from using "write sync" mode to doing explicite syncing. The test is only done once when the first log file is opened in rws mode.
This patch does no change to the rws mode used by the log file writing.
I have run derbyall and the JUnit suite with no errors on Solaris 10. The patch is ready for review and commit.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Dag H. Wanvik (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Dag H. Wanvik updated DERBY-2020:
---------------------------------
Derby Categories: [Performance]
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Store
> Affects Versions: 10.3.1.4
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.1.4
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, releaseNote.html, releaseNote.html, releaseNote.html, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Reopened: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Myrna van Lunteren (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Myrna van Lunteren reopened DERBY-2020:
---------------------------------------
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assignee: Olav Sandstaa
> Fix For: 10.3.0.0
>
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, releaseNote.html, releaseNote.html, releaseNote.html, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Knut Anders Hatlen (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12483953 ]
Knut Anders Hatlen commented on DERBY-2020:
-------------------------------------------
Sorry, I was too quick in my previous comment. #1 is not an issue. You're of course right, the file must be created first in order to get the exception. But I think the issue raised in #2 is valid.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, no-disk-cache.png, rwd.diff, rwd.stat
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Olav Sandstaa updated DERBY-2020:
---------------------------------
Derby Info: [Patch Available]
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-2020) Change file option for syncing log
file to disk from rws to rwd
Posted by "Olav Sandstaa (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-2020?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Olav Sandstaa updated DERBY-2020:
---------------------------------
Attachment: rwd_v2.diff
The only change in this patch (rwd_v2.diff) is to do the actual change of mode for opening log files from "rws" to "rwd" and some corresponding changes in comments.
I have run derbyall and the JUnit suite with any errors.
The patch is ready for review and commit.
> Change file option for syncing log file to disk from rws to rwd
> ---------------------------------------------------------------
>
> Key: DERBY-2020
> URL: https://issues.apache.org/jira/browse/DERBY-2020
> Project: Derby
> Issue Type: Improvement
> Components: Performance, Store
> Affects Versions: 10.3.0.0
> Reporter: Olav Sandstaa
> Assigned To: Olav Sandstaa
> Attachments: disk-cache.png, jvmsyncbug.diff, jvmsyncbug.stat, jvmsyncbug_v2.diff, jvmsyncbug_v2.stat, jvmsyncbug_v3.diff, jvmsyncbug_v3.stat, no-disk-cache.png, rwd.diff, rwd.stat, rwd_pre.diff, rwd_pre.stat, rwd_v2.diff
>
>
> For writing the transaction log to disk Derby uses a
> RandomAccessFile. If it is supported by the JVM, the log files are
> opened in "rws" mode making the file system take care of syncing
> writes to disk. "rws" mode will ensure that both the data and the file
> meta-data is updated for every write to the file. On some operating
> systems (e.g. Solaris) this leads to two write operation to the disk
> for every write issued by Derby. This is limiting the throughput of
> update intensive applications. If we could change the file mode to
> "rwd" this could reduce the number of updates to the disk.
> I have run some simple tests where I have changed mode from "rws" to
> "rwd" for the Derby log file. When running a small numbers of
> concurrent client threads the throughput is almost doubled and the
> response time is almost halved. I will attach some graphs that show
> this when running a given number of concurrent "tpc-b" like clients. These
> graphs show the throughput when running with "rws" and "rwd" mode when the
> disk's write cache has been enabled and disabled.
> I am creating this Jira to have a place where we can collect
> information about issues both for and against changing the default
> mode for writing to log files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.