You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@lucene.apache.org by "Michael McCandless (JIRA)" <ji...@apache.org> on 2008/01/07 17:54:33 UTC
[jira] Created: (LUCENE-1121) Use nio.transferTo when copying large
blocks of bytes
Use nio.transferTo when copying large blocks of bytes
-----------------------------------------------------
Key: LUCENE-1121
URL: https://issues.apache.org/jira/browse/LUCENE-1121
Project: Lucene - Java
Issue Type: Improvement
Components: Store
Reporter: Michael McCandless
Assignee: Michael McCandless
Priority: Minor
When building a CFS file, and also when merging stored fields (and
term vectors, with LUCENE-1120), we copy large blocks of bytes at
once.
We currently do this with an intermediate buffer.
But, nio.transferTo should be somewhat faster on OS's that offer low
level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Commented: (LUCENE-1121) Use nio.transferTo when copying
large blocks of bytes
Posted by "Michael McCandless (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12561789#action_12561789 ]
Michael McCandless commented on LUCENE-1121:
--------------------------------------------
That's interesting ... I'll test Sun's JVM 1.6 on Linux.
Maybe we should commit this, but, leave the default copy method using intermediate buffer? The patch adds set/getCopyMethod to FSDirectory.
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch, LUCENE-1121.patch, testIO.java
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Commented: (LUCENE-1121) Use nio.transferTo when copying
large blocks of bytes
Posted by "Raghu Angadi (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12585677#action_12585677 ]
Raghu Angadi commented on LUCENE-1121:
--------------------------------------
Only savings I would expect from transferTo() would be CPU reduction. Does the benchmark above measure wall clock time or "cpu time"? Btw, the windows results are pretty... strange.
HADOOP-3164 shows expected CPU benefit. Still need to do more extensive tests where I max out CPU with and without patch and compare the wall clock time. Initial test just compares cpu reported on /proc/pid/stat with a test that is disk bound.
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch, LUCENE-1121.patch, testIO.java
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Commented: (LUCENE-1121) Use nio.transferTo when copying
large blocks of bytes
Posted by "Mark Miller (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12763573#action_12763573 ]
Mark Miller commented on LUCENE-1121:
-------------------------------------
NM - it appears that when you chunk, you lose the CPU win - and when you don't chunk, you get the win, but it performs nasty after other java io operations. Bummer.
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch, LUCENE-1121.patch, testIO.java
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Commented: (LUCENE-1121) Use nio.transferTo when copying
large blocks of bytes
Posted by "Mark Miller (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12763544#action_12763544 ]
Mark Miller commented on LUCENE-1121:
-------------------------------------
Isn't this still a nice little optimization for compound copies? When not using Win server, its faster in general, and even when similar, you get the less CPU usage optimization.
At worst it seems we should enable for that case when detecting non windows? We could even throw in a couple specific Windows versions we know work well - the XP results I got were fantastic, and the ones Mike got were not bad. Prob not necessary, as most deployments will prob be on server, but future versions might be better.
Seems like a little win on 'nix systems anyway, just from the CPU savings.
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch, LUCENE-1121.patch, testIO.java
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Commented: (LUCENE-1121) Use nio.transferTo when copying
large blocks of bytes
Posted by "Doug Cutting (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12561778#action_12561778 ]
Doug Cutting commented on LUCENE-1121:
--------------------------------------
For Hadoop, we've seen significant performance improvements on Linux in Sun's 1.6 over 1.5. Clearly, 1.6 didn't help on Windows Server 2003, but it would be good to know if there are any cases where it makes a huge improvement. If there are, then it could be a useful option.
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch, LUCENE-1121.patch, testIO.java
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Commented: (LUCENE-1121) Use nio.transferTo when copying
large blocks of bytes
Posted by "Michael McCandless (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12561982#action_12561982 ]
Michael McCandless commented on LUCENE-1121:
--------------------------------------------
OK I ran Sun JDK 1.6.0_04 on Linux:
Linux 2.6.22, single SATA drive, ext3:
create 500 MB file... 13088 msec
transferTo... 12796 msec
create 500 MB file... 10727 msec
buffer... 12291 msec
SLOWER 4.109%
Linux 2.6.22, on 6-drive RAID 5 array, reiserfs:
create 500 MB file... 11135 msec
transferTo... 11068 msec
create 500 MB file... 8599 msec
buffer... 10708 msec
SLOWER 3.362%
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch, LUCENE-1121.patch, testIO.java
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Updated: (LUCENE-1121) Use nio.transferTo when copying large
blocks of bytes
Posted by "Michael McCandless (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Michael McCandless updated LUCENE-1121:
---------------------------------------
Attachment: testIO.java
Attaching standalone test (testIO.java). Just run it like this:
java testIO 50
and it will create a 500 MB file and test copying it w/ transferTo vs
intermediate buffer.
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch, LUCENE-1121.patch, testIO.java
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Updated: (LUCENE-1121) Use nio.transferTo when copying large
blocks of bytes
Posted by "Michael McCandless (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Michael McCandless updated LUCENE-1121:
---------------------------------------
Attachment: LUCENE-1121.patch
Attached patch. All tests pass.
We shouldn't push this into 2.3.
I still need to test across more platforms and see what performance
impact is.
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Resolved: (LUCENE-1121) Use nio.transferTo when copying
large blocks of bytes
Posted by "Michael McCandless (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Michael McCandless resolved LUCENE-1121.
----------------------------------------
Resolution: Won't Fix
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch, LUCENE-1121.patch, testIO.java
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Updated: (LUCENE-1121) Use nio.transferTo when copying large
blocks of bytes
Posted by "Michael McCandless (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Michael McCandless updated LUCENE-1121:
---------------------------------------
Attachment: LUCENE-1121.patch
Attached patch. All tests pass ... but, I don't think we should
commit this.
I ran performance tests across several platforms. All times are best
of 3 runs, indexing first 200K docs of Wikipedia. I used
SerialMergeScheduler for these tests so I could more easily measure
the impact on merging as well:
Linux (2.6.22), ReiserFS on RAID5 array: 528.1 sec vs 537.0 sec ( 1.7% faster)
Mac OS X 10.4 on RAID0 array: 402.6 sec vs 405.0 sec ( 0.6% faster)
Windows Server 2003 R64 on RAID0 array: 472.3 sec vs 752.6 sec (59.3% SLOWER)
I was rather stunned by the result on Windows Server 2003; I ran that
test twice to be sure. It's really true. My only guess is write
caching (which is turned on for this drive) is somehow not used when
using transferTo.
So then I made a standalone test that creates a big file (you specify
the size X 10 MB), and then copies that big file using transferTo and
then using an intermediate 64 KB buffer. Results below:
OS X 10.4 on external firewire drive: FASTER
create 500 MB file... 31689 msec
transferTo... 31947 msec
create 500 MB file... 31412 msec
buffer... 31215 msec
SLOWER 2.345%
OS X 10.4 on 4-drive RAID 0 array
create 500 MB file... 2409 msec
transferTo... 2449 msec
create 500 MB file... 2366 msec
buffer... 2649 msec
FASTER 7.55%
Linux 2.6.22 on single SATA drive, ext3
create 500 MB file... 12841 msec
transferTo... 12438 msec
create 500 MB file... 11219 msec
buffer... 12003 msec
SLOWER 3.624%
Linux 2.6.22 on 6-drive RAID 5 array, ext3
create 500 MB file... 9647 msec
transferTo... 9107 msec
create 500 MB file... 9092 msec
buffer... 10089 msec
FASTER 9.733%
Windows Server 2003 64 R2, single NTFS internal SATA drive
create 500 MB file... 32485 msec
transferTo... 38922 msec
create 500 MB file... 33484 msec
buffer... 1375 msec
SLOWER 2,730.691%
Windows XP Pro SP2, laptop hard drive
create 200 MB file... 20159 msec
transferTo... 17515 msec
create 200 MB file... 24265 msec
buffer... 18397 msec
FASTER 4.794%
Bottom line is: FileChannel.transferTo is not always a win, and, can
be a catastrophic loss. I think we should stick with tried & true,
simple, buffer copying, at least for now...
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch, LUCENE-1121.patch
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Commented: (LUCENE-1121) Use nio.transferTo when copying
large blocks of bytes
Posted by "Mark Miller (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12561886#action_12561886 ]
Mark Miller commented on LUCENE-1121:
-------------------------------------
Here are some more results from a windows xp and server 2003 machine. This is with java 1.6.
Windows 2003 R2 - internal sata drive
D:\>java Test 50
create 500 MB file... 28625 msec
transferTo... 17656 msec
create 500 MB file... 13390 msec
buffer... 8391 msec
SLOWER 110.416%
D:\>java Test 50
create 500 MB file... 14141 msec
transferTo... 8765 msec
create 500 MB file... 13531 msec
buffer... 1531 msec
SLOWER 472.502%
D:\>java Test 50
create 500 MB file... 13578 msec
transferTo... 9282 msec
create 500 MB file... 13391 msec
buffer... 1235 msec
SLOWER 651.579%
Windows XP SP2 - laptop drive
D:\>java Test 50
create 500 MB file... 18737 msec
transferTo... 28239 msec
create 500 MB file... 19113 msec
buffer... 65839 msec
FASTER 57.109%
D:\>java Test 50
create 500 MB file... 21785 msec
transferTo... 24801 msec
create 500 MB file... 17940 msec
buffer... 33615 msec
FASTER 26.22%
D:\>java Test 50
create 500 MB file... 22520 msec
transferTo... 24300 msec
create 500 MB file... 19644 msec
buffer... 34349 msec
FASTER 29.256%
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch, LUCENE-1121.patch, testIO.java
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Commented: (LUCENE-1121) Use nio.transferTo when copying
large blocks of bytes
Posted by "Doug Cutting (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12561539#action_12561539 ]
Doug Cutting commented on LUCENE-1121:
--------------------------------------
What JVM were these tests run with?
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch, LUCENE-1121.patch, testIO.java
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org
[jira] Commented: (LUCENE-1121) Use nio.transferTo when copying
large blocks of bytes
Posted by "Michael McCandless (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/LUCENE-1121?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12561609#action_12561609 ]
Michael McCandless commented on LUCENE-1121:
--------------------------------------------
Sun's JVM, 1.4 (on the Windows XP Pro SP2 laptop), Sun's JVM 1.6 (on the Windows Server 2003 64 R2 machine), Sun's JVM 1.5 on Linux and Apple's release of Sun's JVM for the two OS X runs.
> Use nio.transferTo when copying large blocks of bytes
> -----------------------------------------------------
>
> Key: LUCENE-1121
> URL: https://issues.apache.org/jira/browse/LUCENE-1121
> Project: Lucene - Java
> Issue Type: Improvement
> Components: Store
> Reporter: Michael McCandless
> Assignee: Michael McCandless
> Priority: Minor
> Attachments: LUCENE-1121.patch, LUCENE-1121.patch, testIO.java
>
>
> When building a CFS file, and also when merging stored fields (and
> term vectors, with LUCENE-1120), we copy large blocks of bytes at
> once.
> We currently do this with an intermediate buffer.
> But, nio.transferTo should be somewhat faster on OS's that offer low
> level IO APIs for moving blocks of bytes between files.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
---------------------------------------------------------------------
To unsubscribe, e-mail: java-dev-unsubscribe@lucene.apache.org
For additional commands, e-mail: java-dev-help@lucene.apache.org