fat: improve sync performance by grouping writes revised
Subsystems (2)
PATCH 1/1 fat: improve sync performance by grouping writes revised
From: Holden Karau <[email protected]> http://www.holdenkarau.com
This is an attempt at improving fat_mirror_bhs in sync mode [namely it writes all of the data for a backup block, and then blocks untill finished]. The old behavior would write & block in smaller chunks, so this should be slightly faster. It also removes the fix me requesting that it be fixed to behave this way :-)
---
This is an improved version of an earlier patch, I've cleaned up the
formatting and it now also groups the write for the primary fat block
[so even if the user has only 2 FATs it should still be slightly
faster]. If no one objects, I'd like to see if it would be possible to
put this in the -mm tree to make sure it doesn't eat anyones fs :-)
In case the patch gets mangled I've put it up at http://www.holdenkarau.com/~holden/projects/fat/001_improve_fat_sync_performance_revised.patch
And now for the actual patch:
fs/fat/fatent.c +40 -36
@@ -1,5 +1,6 @@/* * Copyright (C) 2004, OGAWA Hirofumi +* Copyright (C) 2006, Holden Karau [Xandros] * Released under GPL v2. */
@@ -343,52 +344,65 @@ int fat_ent_read(struct inode *inode, streturn ops->ent_get (fatent); } -/* FIXME: We can write the blocks as more big chunk. */ -static int fat_mirror_bhs (struct super_block *sb,struct buffer_head **bhs, -int nr_bhs) + +static int fat_mirror_bhs_optw (struct super_block *sb,struct buffer_head **bhs, +int nr_bhs ,int wait) {struct msdos_sb_info *sbi =MSDOS_SB (sb); -struct buffer_head *c_bh; +struct buffer_head *c_bh[nr_bhs*(sbi->fats)];int err, n, copy; +/* Always wait if mounted -o sync */ +if (sb->s_flags &MS_SYNCHRONOUS ) + wait =1 ; err =0 ;for (copy =1 ; copy < sbi->fats; copy++) {sector_t backup_fat = sbi->fat_length * copy; - -for (n =0 ; n < nr_bhs; n++) { - c_bh =sb_getblk (sb, backup_fat + bhs[n]->b_blocknr); -if (!c_bh) { +for (n =0 ; n < nr_bhs ; n++ ) { + c_bh[(copy-1 )*nr_bhs+n] =sb_getblk (sb, backup_fat + bhs[n]->b_blocknr); +if (!c_bh[(copy-1 )*nr_bhs+n]) { +printk (KERN_CRIT "fat: out of memory while copying backup fat. possible data loss\n" ); err = -ENOMEM ; goto error; } -memcpy (c_bh->b_data, bhs[n]->b_data, sb->s_blocksize); -set_buffer_uptodate (c_bh); -mark_buffer_dirty (c_bh); -if (sb->s_flags &MS_SYNCHRONOUS ) - err =sync_dirty_buffer (c_bh); -brelse (c_bh); -if (err) - goto error; +memcpy (c_bh[(copy-1 )*nr_bhs+n]->b_data, bhs[n]->b_data, sb->s_blocksize); +set_buffer_uptodate (c_bh[(copy-1 )*nr_bhs+n]); +mark_buffer_dirty (c_bh[(copy-1 )*nr_bhs+n]); } } + +if (wait) { +for (n =0 ; n < nr_bhs ; n++) { +printk ("copying to %d to %d\n" ,n, nr_bhs*(sbi->fats-1 )+n); + c_bh[nr_bhs*(sbi->fats-1 )+n] = bhs[n]; +printk ("done , %p==%p\n" , c_bh[nr_bhs*(sbi->fats-1 )+n] , bhs[n]); + } + } + err =fat_sync_bhs_optw ( c_bh , nr_bhs*(sbi->fats+wait-1 ) , wait ); +if (err) + goto error; +for (n =0 ; n < nr_bhs*(sbi->fats-1 ); n++ ) { +brelse (c_bh[n]); + } error:return err; } +static inline int fat_mirror_bhs (struct super_block *sb,struct buffer_head **bhs, +int nr_bhs ) +{ +return fat_mirror_bhs_optw (sb , bhs , nr_bhs,0 ); +} + +int fat_ent_write (struct inode *inode,struct fat_entry *fatent,int new,int wait) {struct super_block *sb = inode->i_sb;struct fatent_operations *ops =MSDOS_SB (sb)->fatent_ops; -int err; ops->ent_put (fatent, new); -if (wait) { - err =fat_sync_bhs (fatent->bhs, fatent->nr_bhs); -if (err) -return err; - } -return fat_mirror_bhs (sb, fatent->bhs, fatent->nr_bhs); +return fat_mirror_bhs_optw (sb, fatent->bhs, fatent->nr_bhs , wait); } static inline int fat_ent_next(struct msdos_sb_info *sbi,
@@ -505,9 +519,9 @@ out:fatent_brelse (&fatent);if (!err) {if (inode_needs_sync (inode)) - err =fat_sync_bhs (bhs, nr_bhs); -if (!err) - err =fat_mirror_bhs (sb, bhs, nr_bhs); + err =fat_mirror_bhs_optw (sb , bhs, nr_bhs ,1 ); +else + err =fat_mirror_bhs_optw (sb, bhs, nr_bhs ,0 ); }for (i =0 ; i < nr_bhs; i++)brelse (bhs[i]);
@@ -549,11 +563,6 @@ int fat_free_clusters(struct inode *inod }if (nr_bhs + fatent.nr_bhs >MAX_BUF_PER_PAGE ) { -if (sb->s_flags &MS_SYNCHRONOUS ) { - err =fat_sync_bhs (bhs, nr_bhs); -if (err) - goto error; - } err =fat_mirror_bhs (sb, bhs, nr_bhs);if (err) goto error;
@@ -564,11 +573,6 @@ int fat_free_clusters(struct inode *inodfat_collect_bhs (bhs, &nr_bhs, &fatent); }while (cluster !=FAT_ENT_EOF ); -if (sb->s_flags &MS_SYNCHRONOUS ) { - err =fat_sync_bhs (bhs, nr_bhs); -if (err) - goto error; - } err =fat_mirror_bhs (sb, bhs, nr_bhs); error:fatent_brelse (&fatent);
fs/fat/misc.c +17 -8
@@ -194,19 +194,28 @@ void fat_date_unix2dos(int unix_date, __EXPORT_SYMBOL_GPL (fat_date_unix2dos); -int fat_sync_bhs (struct buffer_head **bhs,int nr_bhs) + + +int fat_sync_bhs_optw (struct buffer_head **bhs,int nr_bhs ,int wait) {int i, err =0 ;ll_rw_block (SWRITE , nr_bhs, bhs); -for (i =0 ; i < nr_bhs; i++) { -wait_on_buffer (bhs[i]); -if (buffer_eopnotsupp (bhs[i])) { -clear_buffer_eopnotsupp (bhs[i]); - err = -EOPNOTSUPP ; - }else if (!err && !buffer_uptodate (bhs[i])) - err = -EIO ; +if (wait) { +for (i =0 ; i < nr_bhs; i++) { +wait_on_buffer (bhs[i]); +if (buffer_eopnotsupp (bhs[i])) { +clear_buffer_eopnotsupp (bhs[i]); + err = -EOPNOTSUPP ; + }else if (!err && !buffer_uptodate (bhs[i])) + err = -EIO ; + } } +return err; } +inline int fat_sync_bhs (struct buffer_head **bhs,int nr_bhs ) { +return fat_sync_bhs_optw (bhs , nr_bhs ,1 ); +} +
include/linux/msdos_fs.h +1 -0
@@ -419,6 +419,7 @@ extern int fat_chain_add(struct inode *iextern int date_dos2unix (unsigned short time,unsigned short date);extern void fat_date_unix2dos (int unix_date,__le16 *time,__le16 *date);extern int fat_sync_bhs (struct buffer_head **bhs,int nr_bhs); +extern int fat_sync_bhs_optw (struct buffer_head **bhs,int nr_bhs,int wait);int fat_cache_init (void );void fat_cache_destroy (void );
Quoted 20 lines · Holden Karau
fs/fat/fatent.c +7
-4@@ -343,52 +344,65 @@ int fat_ent_read(struct inode *inode, streturn ops->ent_get (fatent); } -/* FIXME: We can write the blocks as more big chunk. */ -static int fat_mirror_bhs (struct super_block *sb,struct buffer_head **bhs, -int nr_bhs) + +static int fat_mirror_bhs_optw (struct super_block *sb,struct buffer_head **bhs, +int nr_bhs ,int wait) {struct msdos_sb_info *sbi =MSDOS_SB (sb); -struct buffer_head *c_bh; +struct buffer_head *c_bh[nr_bhs*(sbi->fats)];int err, n, copy; +/* Always wait if mounted -o sync */ +if (sb->s_flags &MS_SYNCHRONOUS ) + wait =1 ; err =0 ;
fs/fat/fatent.c int fat_ent_read(struct inode *inode, st · line 364
Quoted 10 lines
fs/fat/fatent.c +4
-4for (copy =1 ; copy < sbi->fats; copy++) {sector_t backup_fat = sbi->fat_length * copy; - -for (n =0 ; n < nr_bhs; n++) { - c_bh =sb_getblk (sb, backup_fat + bhs[n]->b_blocknr); -if (!c_bh) { +for (n =0 ; n < nr_bhs ; n++ ) { + c_bh[(copy-1 )*nr_bhs+n] =sb_getblk (sb, backup_fat + bhs[n]->b_blocknr); +if (!c_bh[(copy-1 )*nr_bhs+n]) { +printk (KERN_CRIT "fat: out of memory while copying backup fat. possible data loss\n" );
I don't like that at all.
Quoted 10 lines
fs/fat/fatent.c +0
-7err = -ENOMEM ; goto error; } -memcpy (c_bh->b_data, bhs[n]->b_data, sb->s_blocksize); -set_buffer_uptodate (c_bh); -mark_buffer_dirty (c_bh); -if (sb->s_flags &MS_SYNCHRONOUS ) - err =sync_dirty_buffer (c_bh); -brelse (c_bh); -if (err)
fs/fat/fatent.c int fat_ent_read(struct inode *inode, st · line 376
Quoted 10 lines
fs/fat/fatent.c +7
-1- goto error; +memcpy (c_bh[(copy-1 )*nr_bhs+n]->b_data, bhs[n]->b_data, sb->s_blocksize); +set_buffer_uptodate (c_bh[(copy-1 )*nr_bhs+n]); +mark_buffer_dirty (c_bh[(copy-1 )*nr_bhs+n]); } } + +if (wait) { +for (n =0 ; n < nr_bhs ; n++) { +printk ("copying to %d to %d\n" ,n, nr_bhs*(sbi->fats-1 )+n);
Is this the right version of the patch? The printk should never be left in. Plus, as far as I can tell, that whole loop is actually just memcpy().
Quoted 17 lines · Matthew Wilcox
Quoted 16 lines · Holden Karau
fs/fat/fatent.c +4
-4@@ -343,52 +344,65 @@ int fat_ent_read(struct inode *inode, streturn ops->ent_get (fatent); } -/* FIXME: We can write the blocks as more big chunk. */ -static int fat_mirror_bhs (struct super_block *sb,struct buffer_head **bhs, -int nr_bhs) + +static int fat_mirror_bhs_optw (struct super_block *sb,struct buffer_head **bhs, +int nr_bhs ,int wait) {struct msdos_sb_info *sbi =MSDOS_SB (sb); -struct buffer_head *c_bh; +struct buffer_head *c_bh[nr_bhs*(sbi->fats)];int err, n, copy;
Quoted 16 lines
Quoted 4 lines
fs/fat/fatent.c +3
-0+/* Always wait if mounted -o sync */ +if (sb->s_flags &MS_SYNCHRONOUS ) + wait =1 ; err =0 ;fs/fat/fatent.c int fat_ent_read(struct inode *inode, st · line 364
Quoted 10 lines
fs/fat/fatent.c +4
-4for (copy =1 ; copy < sbi->fats; copy++) {sector_t backup_fat = sbi->fat_length * copy; - -for (n =0 ; n < nr_bhs; n++) { - c_bh =sb_getblk (sb, backup_fat + bhs[n]->b_blocknr); -if (!c_bh) { +for (n =0 ; n < nr_bhs ; n++ ) { + c_bh[(copy-1 )*nr_bhs+n] =sb_getblk (sb, backup_fat + bhs[n]->b_blocknr); +if (!c_bh[(copy-1 )*nr_bhs+n]) { +printk (KERN_CRIT "fat: out of memory while copying backup fat. possible data loss\n" );I don't like that at all.
Not much to be done about that. The amount of memory required is fairly small, but if its not there its not there.
Quoted 22 lines
Quoted 11 lines
fs/fat/fatent.c +0
-7err = -ENOMEM ; goto error; } -memcpy (c_bh->b_data, bhs[n]->b_data, sb->s_blocksize); -set_buffer_uptodate (c_bh); -mark_buffer_dirty (c_bh); -if (sb->s_flags &MS_SYNCHRONOUS ) - err =sync_dirty_buffer (c_bh); -brelse (c_bh); -if (err)fs/fat/fatent.c int fat_ent_read(struct inode *inode, st · line 376
Quoted 10 lines
fs/fat/fatent.c +7
-1- goto error; +memcpy (c_bh[(copy-1 )*nr_bhs+n]->b_data, bhs[n]->b_data, sb->s_blocksize); +set_buffer_uptodate (c_bh[(copy-1 )*nr_bhs+n]); +mark_buffer_dirty (c_bh[(copy-1 )*nr_bhs+n]); } } + +if (wait) { +for (n =0 ; n < nr_bhs ; n++) { +printk ("copying to %d to %d\n" ,n, nr_bhs*(sbi->fats-1 )+n);
Quoted 2 lines
Is this the right version of the patch? The printk should never be left in. Plus, as far as I can tell, that whole loop is actually just
memcpy().
whoops. That was in for debugging, I thought I took that out. The loop structure is how it was before, but I don't see a way to get rid of it, do you have an idea?
Quoted 1 line
Signature · 1 line
Cell: 613-276-1645
I was thinking about the issue of running out of memory, while its not particularly likely to happen except on devices with huge disks and tiney amount of memory, it is a possibility. I can make it fall-through to the previous way of doing things, does that sound like a reasonable idea?
Quoted 69 lines · Holden Karau
Quoted 17 lines · Matthew Wilcox
Quoted 16 lines · Holden Karau
fs/fat/fatent.c +4
-4@@ -343,52 +344,65 @@ int fat_ent_read(struct inode *inode, streturn ops->ent_get (fatent); } -/* FIXME: We can write the blocks as more big chunk. */ -static int fat_mirror_bhs (struct super_block *sb,struct buffer_head **bhs, -int nr_bhs) + +static int fat_mirror_bhs_optw (struct super_block *sb,struct buffer_head **bhs, +int nr_bhs ,int wait) {struct msdos_sb_info *sbi =MSDOS_SB (sb); -struct buffer_head *c_bh; +struct buffer_head *c_bh[nr_bhs*(sbi->fats)];int err, n, copy;Quoted 16 lines
Quoted 4 lines
fs/fat/fatent.c +3
-0+/* Always wait if mounted -o sync */ +if (sb->s_flags &MS_SYNCHRONOUS ) + wait =1 ; err =0 ;fs/fat/fatent.c int fat_ent_read(struct inode *inode, st · line 364
Quoted 10 lines
fs/fat/fatent.c +4
-4for (copy =1 ; copy < sbi->fats; copy++) {sector_t backup_fat = sbi->fat_length * copy; - -for (n =0 ; n < nr_bhs; n++) { - c_bh =sb_getblk (sb, backup_fat + bhs[n]->b_blocknr); -if (!c_bh) { +for (n =0 ; n < nr_bhs ; n++ ) { + c_bh[(copy-1 )*nr_bhs+n] =sb_getblk (sb, backup_fat + bhs[n]->b_blocknr); +if (!c_bh[(copy-1 )*nr_bhs+n]) { +printk (KERN_CRIT "fat: out of memory while copying backup fat. possible data loss\n" );I don't like that at all.
Not much to be done about that. The amount of memory required is fairly small, but if its not there its not there.
Quoted 22 lines
Quoted 11 lines
fs/fat/fatent.c +0
-7err = -ENOMEM ; goto error; } -memcpy (c_bh->b_data, bhs[n]->b_data, sb->s_blocksize); -set_buffer_uptodate (c_bh); -mark_buffer_dirty (c_bh); -if (sb->s_flags &MS_SYNCHRONOUS ) - err =sync_dirty_buffer (c_bh); -brelse (c_bh); -if (err)fs/fat/fatent.c int fat_ent_read(struct inode *inode, st · line 376
Quoted 10 lines
fs/fat/fatent.c +7
-1- goto error; +memcpy (c_bh[(copy-1 )*nr_bhs+n]->b_data, bhs[n]->b_data, sb->s_blocksize); +set_buffer_uptodate (c_bh[(copy-1 )*nr_bhs+n]); +mark_buffer_dirty (c_bh[(copy-1 )*nr_bhs+n]); } } + +if (wait) { +for (n =0 ; n < nr_bhs ; n++) { +printk ("copying to %d to %d\n" ,n, nr_bhs*(sbi->fats-1 )+n);Quoted 2 lines
Is this the right version of the patch? The printk should never be left in. Plus, as far as I can tell, that whole loop is actually just
memcpy().whoops. That was in for debugging, I thought I took that out. The loop structure is how it was before, but I don't see a way to get rid of it, do you have an idea?
Quoted 1 line
--
Cell: 613-276-1645
Signature · 1 line
Cell: 613-276-1645
Quoted 5 lines · Holden Karau
I was thinking about the issue of running out of memory, while its not particularly likely to happen except on devices with huge disks and tiney amount of memory, it is a possibility. I can make it fall-through to the previous way of doing things, does that sound like a reasonable idea?
Yes, or you could make it sync the ones for which you did have enough memory, and then restart.
fs/fat/fatent.c int fat_ent_read(struct inode *inode, st · line 352
Quoted 6 lines · Holden Karau
fs/fat/fatent.c +3
-1+static int fat_mirror_bhs_optw (struct super_block *sb,struct buffer_head **bhs, +int nr_bhs ,int wait) {struct msdos_sb_info *sbi =MSDOS_SB (sb); -struct buffer_head *c_bh; +struct buffer_head *c_bh[nr_bhs*(sbi->fats)];
Variable-sized array on the kernel-stack? That can easily explode in your hands. Unless you are _very_ sure about the bounds, you should do an explicit kmalloc. And if you were that sure, you could just as well have an array with fixed size.
Quoted 1 line
fs/fat/fatent.c +1
-0+if (sb->s_flags &MS_SYNCHRONOUS )
[...]
Quoted 1 line
(quoted diff) +1
-0+ }
[...]
fs/fat/fatent.c int fat_ent_read(struct inode *inode, st · line 392
Quoted 1 line
fs/fat/fatent.c +1
-0+ int nr_bhs )
Trailing whitespace in those lines.
Jörn
Signature · 6 lines
Prosperity makes friends, adversity tries them. -- Publilius Syrus - To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Quoted 8 lines · Jörn Engel
fs/fat/fatent.c int fat_ent_read(struct inode *inode, st · line 352
Quoted 6 lines · Holden Karau
fs/fat/fatent.c +3
-1+static int fat_mirror_bhs_optw (struct super_block *sb,struct buffer_head **bhs, +int nr_bhs ,int wait) {struct msdos_sb_info *sbi =MSDOS_SB (sb); -struct buffer_head *c_bh; +struct buffer_head *c_bh[nr_bhs*(sbi->fats)];
Quoted 5 lines
Variable-sized array on the kernel-stack? That can easily explode in your hands. Unless you are _very_ sure about the bounds, you should do an explicit kmalloc. And if you were that sure, you could just as well have an array with fixed size.
sbi->fats has a range of 2 to 4, but I suppose that might concievably change if someone decides they want a fat filesystem with a lot of backup FATs and modifies some other parts of the driver to support that. I'll change it to use kmalloc.
Quoted 7 lines
Quoted 1 line
+ if (
sb->s_flags&MS_SYNCHRONOUS)[...]
Quoted 1 line
+ }
[...]
Quoted 1 line
+ int
nr_bhs)Trailing whitespace in those lines.
..... oops. I'll fix that.
Quoted 11 lines
Jörn
--
Prosperity makes friends, adversity tries them.
-- Publilius Syrus
-
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Signature · 5 lines
Cell: 613-276-1645 - To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
OGAWA Hirofumi
maintainerQuoted 6 lines · Holden Karau
From: Holden Karau <[email protected]> http://www.holdenkarau.com
This is an attempt at improvingfat_mirror_bhsin sync mode [namely it writes all of the data for a backup block, and then blocks untill finished]. The old behavior would write & block in smaller chunks, so this should be slightly faster. It also removes the fix me requesting that it be fixed to behave this way :-)
Please post the result of performance test. If it's fairly big, we would be able to use async for mirror FAT. Instead, for hotplug device we can provide the another option.
Signature · 1 line
OGAWA Hirofumi <[email protected]>
The performance increase is pretty small. Using an old external dirve I had lying around I got:
diff -y stock/10k modified/10k
10240+0 records in | 1024+0
records in
10240+0 records out | 1024+0
records out
5242880 bytes transferred in 18.280922 seconds (286795 bytes/ | 524288 bytes transferred in 1.824985 seconds (287283 bytes/se
diff -y stock/1k modified/1k
1024+0 records in 1024+0
records in
1024+0 records out 1024+0
records out
524288 bytes transferred in 1.777250 seconds (295000 bytes/se | 524288 bytes transferred in 1.764748 seconds (297089 bytes/se
The usual disclaimer of any benchmarking applies, YMMV.
Cheers,
Holden :-)
Quoted 15 lines · OGAWA Hirofumi
Quoted 6 lines · Holden Karau
From: Holden Karau <[email protected]> http://www.holdenkarau.com
This is an attempt at improvingfat_mirror_bhsin sync mode [namely it writes all of the data for a backup block, and then blocks untill finished]. The old behavior would write & block in smaller chunks, so this should be slightly faster. It also removes the fix me requesting that it be fixed to behave this way :-)Please post the result of performance test. If it's fairly big, we would be able to use async for mirror FAT. Instead, for hotplug device we can provide the another option.
--
OGAWA Hirofumi <[email protected]>
Signature · 1 line
Cell: 613-276-1645
OGAWA Hirofumi
maintainerQuoted 9 lines · Holden Karau
The performance increase is pretty small. Using an old external dirve I had lying around I got:
diff -y stock/10k modified/10k
10240+0 records in | 1024+0
records in
10240+0 records out | 1024+0
records out
5242880 bytes transferred in 18.280922 seconds (286795 bytes/ | 524288 bytes transferred in 1.824985 seconds (287283 bytes/se
1024 records out 1.824985 seconds. Is there decrease case? I assume the result is same. So, we would need different approach.
Quoted 7 lines
diff -y stock/1k modified/1k
1024+0 records in 1024+0
records in
1024+0 records out 1024+0
records out
524288 bytes transferred in 1.777250 seconds (295000 bytes/se | 524288 bytes transferred in 1.764748 seconds (297089 bytes/se
Signature · 1 line
OGAWA Hirofumi <[email protected]>
Keep in mind these results are with a slow external drive, but yah fat32 sync performance is still really bad.
This patch is just meant to make fat32 sync performance better, not necessarily make it usable for everyone [one step at a time and all that]. FAT32 sync is quite slow (see
http://readlist.com/lists/vger.kernel.org/linux-kernel/22/111761.html
), so if you want fast performance [or have drives with limited write cycles] async is almost definitely the way to go.
I have a patch [not this one] which adds a module param ("fast") which syncs the FAT tables after 30 seconds of no write activity, but I don't think the majority of people are interested in it.
Quoted 25 lines · OGAWA Hirofumi
Quoted 9 lines · Holden Karau
The performance increase is pretty small. Using an old external dirve I had lying around I got:
diff -y stock/10k modified/10k
10240+0 records in | 1024+0
records in
10240+0 records out | 1024+0
records out
5242880 bytes transferred in 18.280922 seconds (286795 bytes/ | 524288 bytes transferred in 1.824985 seconds (287283 bytes/se1024 records out 1.824985 seconds. Is there decrease case? I assume the result is same. So, we would need different approach.
Quoted 7 lines
diff -y stock/1k modified/1k
1024+0 records in 1024+0
records in
1024+0 records out 1024+0
records out
524288 bytes transferred in 1.777250 seconds (295000 bytes/se | 524288 bytes transferred in 1.764748 seconds (297089 bytes/se--
OGAWA Hirofumi <[email protected]>
Signature · 1 line
Cell: 613-276-1645
OGAWA Hirofumi
maintainerQuoted 3 lines · Holden Karau
This patch is just meant to make fat32 sync performance better, not necessarily make it usable for everyone [one step at a time and all that].
Sorry, I can't see your point. The FAT12 and FAT16 also have backup FAT. And the your patch didn't make performance better, right?
Signature · 1 line
OGAWA Hirofumi <[email protected]>
Whoops, sorry about that. Yes it would improve performance on fat12 & fat16 [although I haven't tested it with fat12]. What I meant by that sentance is that, fat sync performance is pretty bad with or without my patch, its just slightly less worse with my patch :-)
Quoted 11 lines · OGAWA Hirofumi
Quoted 3 lines · Holden Karau
This patch is just meant to make fat32 sync performance better, not necessarily make it usable for everyone [one step at a time and all that].
Sorry, I can't see your point. The FAT12 and FAT16 also have backup FAT. And the your patch didn't make performance better, right?
--
OGAWA Hirofumi <[email protected]>
Signature · 1 line
Cell: 613-276-1645