Unixbench shell1 performance regression
Hi folks,
Days ago, I received a XFS Unixbench[1] shell1 (high-concurrency) performance regression during a benchmark comparison between XFS and
EXT4: The XFS result was lower than EXT4 by 15% on Linux 6.6.y with 144-core aarch64 (64K page size). Since Unixbench is somewhat important to indicate overall system performance for many end users, it's not a good result.
shell1 test[2] basically runs in a loop that it executes commands to generate files (sort.$$, od.$$, grep.$$, wc.$$) and then remove them. The testcase lasts for one minute and then show the total number of iterations.
While no difference was observed in single-threaded results, it showed a noticeable difference above if ./Run shell1 -c 144 -i 1 is used.
The original report was on aarch64, but I could still reproduce some difference on Linux 6.13 with a X86 physical machine:
Intel(R) Xeon(R) Platinum 8331C CPU @ 2.50GHz * 96 cores 512 GiB memory
XFS (35649.6) is still lower than EXT4 (37146.0) by 4% and the kconfig is attached.
However, I don't observe much difference on 5.10.y kernels. After collecting some off-CPU trace, I found there are many new agi buf lock waits compared with the correspoinding 5.10.y trace, as below:
rm;el0t_64_sync;el0t_64_sync_handler;el0_svc;do_el0_svc;el0_svc_common.constprop.0;__arm64_sys_unlinkat;do_unlinkat;vfs_unlink;xfs_vn_unlink;xfs_remove;xfs_droplink;xfs_iunlink;xfs_read_agi;xfs_trans_read_buf_map;xfs_buf_read_map;xfs_buf_get_map;xfs_buf_lookup;xfs_buf_find_lock;xfs_buf_lock;down;__down;__down_common;___down_common;schedule_timeout;schedule;finish_task_switch.isra.0 2 .. rm;el0t_64_sync;el0t_64_sync_handler;el0_svc;do_el0_svc;el0_svc_common.constprop.0;__arm64_sys_unlinkat;do_unlinkat;vfs_unlink;xfs_vn_unlink;xfs_remove;xfs_droplink;xfs_iunlink;xfs_read_agi;xfs_trans_read_buf_map;xfs_buf_read_map;xfs_buf_get_map;xfs_buf_lookup;xfs_buf_find_lock;xfs_buf_lock;down;__down;__down_common;___down_common;schedule_timeout;schedule;finish_task_switch.isra.0 2 .. kworker/62:1;ret_from_fork;kthread;worker_thread;process_one_work;xfs_inodegc_worker;xfs_inodegc_inactivate;xfs_inactive;xfs_inactive_ifree;xfs_ifree;xfs_difree;xfs_ialloc_read_agi;xfs_read_agi;xfs_trans_read_buf_map;xfs_buf_read_map;xfs_buf_get_map;xfs_buf_lookup;xfs_buf_find_lock;xfs_buf_lock;down;__down;__down_common;___down_common;schedule_timeout;schedule;finish_task_switch.isra.0 5283 ..
I tried to do some hack to disable defer inode inactivation as below, the shell1 benchmark then recovered: XFS (35649.6 -> 37810.9):
fs/xfs/xfs_icache.c +7 -0
@@ -2059,6 +2059,7 @@ voidxfs_inodegc_start ( struct xfs_mount *mp) { +return ;if (xfs_set_inodegc_enabled (mp))return ;
@@ -2180,6 +2181,12 @@ xfs_inodegc_queue( ip->i_flags |=XFS_NEED_INACTIVE ;spin_unlock (&ip->i_flags_lock); +if (1 ) { +xfs_iflags_set (ip,XFS_INACTIVATING ); +xfs_inodegc_inactivate (ip); +return ; + } + cpu_nr =get_cpu (); gc =this_cpu_ptr (mp->m_inodegc);llist_add (&ip->i_gclist, &gc->list);
I don't have extra slot for now, but hopefully this report could be useful ;) thanks!
Thanks,
Gao Xiang
[1] https://github.com/kdlucas/byte-unixbench
[2] https://github.com/kdlucas/byte-unixbench/blob/master/UnixBench/pgms/tst.sh
Quoted 8 lines · Gao Xiang
Hi folks,
Days ago, I received a XFS Unixbench[1] shell1 (high-concurrency) performance regression during a benchmark comparison between XFS and
EXT4: The XFS result was lower than EXT4 by 15% on Linux 6.6.y with 144-core aarch64 (64K page size). Since Unixbench is somewhat important to indicate overall system performance for many end users, it's not a good result.
Unixbench isn't really that indicative of typical worklaods on large core-count machines these days. It's an ancient benchmark, and it's exceedingly rare that a modern machine is fully loaded with shell scripts such as the shell1 test is running because it's highly inefficient to do large scale concurrent processing of data in this way....
Indeed, look at the file copy "benchmarks" it runs - the use buffer sizes of 256, 1024 and 4096 bytes to tell you how well the filesystem performs. Using sub-page size buffers might have been common for 1983-era CPUs to get the highest possible file copy throughput, but these days these are slow paths that we largely don't optimise for highest throughput. Measuring modern system scalability via how such operations perform is largely meaningless because applications don't behave this way anymore....
Quoted 7 lines
shell1 test[2] basically runs in a loop that it executes commands to generate files (sort.$$, od.$$, grep.$$, wc.$$) and then remove them. The testcase lasts for one minute and then show the total number of iterations.
While no difference was observed in single-threaded results, it showed a noticeable difference above if
./Run shell1 -c 144 -i 1is used.
I'm betting that the XFS filesystem is small and only has 4 AGs, and so has very limited concurrency in allocation.
i.e. you're trying to run a massively concurrent workload on a filesystem that only has - at best - the ability to do 4 allocations or frees at a time. Of course it is going to contend on the allocation group locks....
Quoted 6 lines
The original report was on aarch64, but I could still reproduce some difference on Linux 6.13 with a X86 physical machine:
Intel(R) Xeon(R) Platinum 8331C CPU @ 2.50GHz * 96 cores 512 GiB memory
Quoted 6 lines
XFS (35649.6) is still lower than EXT4 (37146.0) by 4% and the kconfig is attached.
However, I don't observe much difference on 5.10.y kernels. After collecting some off-CPU trace, I found there are many new agi buf lock waits compared with the correspoinding 5.10.y trace, as below:
Yes, because background inactivation can increase the contention on AGF/AGI buffer locks when there is insufficient concurrency in the filesystem layout. It is rare, however, that any workload other that benchmarks generate enough load and/or concurrency to reach the thresholds where such lock breakdown occurs.
Quoted 16 lines
I tried to do some hack to disable defer inode inactivation as below, the shell1 benchmark then recovered: XFS (35649.6 -> 37810.9):
fs/xfs/xfs_icache.c +1
-0@@ -2059,6 +2059,7 @@ voidxfs_inodegc_start ( struct xfs_mount *mp) { +return ;if (xfs_set_inodegc_enabled (mp))return ;
fs/xfs/xfs_icache.c xfs_inodegc_queue( · line 2188
Quoted 8 lines
fs/xfs/xfs_icache.c +5
-0@@ -2180,6 +2181,12 @@ xfs_inodegc_queue( ip->i_flags |=XFS_NEED_INACTIVE ;spin_unlock (&ip->i_flags_lock); +if (1 ) { +xfs_iflags_set (ip,XFS_INACTIVATING ); +xfs_inodegc_inactivate (ip); +return ; + }
That reintroduces potential deadlock vectors by running blocking transactions directly from iput() and/or memory reclaim. That's one of the main reasons we moved inactivation to a background thread - it gets rid of an entire class of potential deadlock problems....
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Hi Dave,
Quoted 17 lines · Dave Chinner
Quoted 8 lines · Gao Xiang
Hi folks,
Days ago, I received a XFS Unixbench[1] shell1 (high-concurrency) performance regression during a benchmark comparison between XFS and
EXT4: The XFS result was lower than EXT4 by 15% on Linux 6.6.y with 144-core aarch64 (64K page size). Since Unixbench is somewhat important to indicate overall system performance for many end users, it's not a good result.Unixbench isn't really that indicative of typical worklaods on large core-count machines these days. It's an ancient benchmark, and it's exceedingly rare that a modern machine is fully loaded with shell scripts such as the shell1 test is running because it's highly inefficient to do large scale concurrent processing of data in this way....
Quoted 8 lines
Indeed, look at the file copy "benchmarks" it runs - the use buffer sizes of 256, 1024 and 4096 bytes to tell you how well the filesystem performs. Using sub-page size buffers might have been common for 1983-era CPUs to get the highest possible file copy throughput, but these days these are slow paths that we largely don't optimise for highest throughput. Measuring modern system scalability via how such operations perform is largely meaningless because applications don't behave this way anymore....
Thanks for your reply!
Sigh. Many customers really care, and they select the whole software stack based on this benchmark.
If they think the results are not good, they might ask us to move away of XFS filesystem. It's not what I could do anything, you know.
Quoted 9 lines
Quoted 8 lines
shell1 test[2] basically runs in a loop that it executes commands to generate files (sort.$$, od.$$, grep.$$, wc.$$) and then remove them. The testcase lasts for one minute and then show the total number of iterations.
While no difference was observed in single-threaded results, it showed a noticeable difference above if
./Run shell1 -c 144 -i 1is used.
Quoted 7 lines
I'm betting that the XFS filesystem is small and only has 4 AGs, and so has very limited concurrency in allocation.
i.e. you're trying to run a massively concurrent workload on a filesystem that only has - at best - the ability to do 4 allocations or frees at a time. Of course it is going to contend on the allocation group locks....
I've adjusted this, from 4 AG to 20 AG. No real impact.
Quoted 39 lines
Quoted 7 lines
The original report was on aarch64, but I could still reproduce some difference on Linux 6.13 with a X86 physical machine:
Intel(R) Xeon(R) Platinum 8331C CPU @ 2.50GHz * 96 cores 512 GiB memory
Quoted 6 lines
XFS (35649.6) is still lower than EXT4 (37146.0) by 4% and the kconfig is attached.
However, I don't observe much difference on 5.10.y kernels. After collecting some off-CPU trace, I found there are many new agi buf lock waits compared with the correspoinding 5.10.y trace, as below:
Yes, because background inactivation can increase the contention on AGF/AGI buffer locks when there is insufficient concurrency in the filesystem layout. It is rare, however, that any workload other that benchmarks generate enough load and/or concurrency to reach the thresholds where such lock breakdown occurs.
Quoted 19 lines
I tried to do some hack to disable defer inode inactivation as below, the shell1 benchmark then recovered: XFS (35649.6 -> 37810.9):
fs/xfs/xfs_icache.c +1
-0@@ -2059,6 +2059,7 @@ voidxfs_inodegc_start ( struct xfs_mount *mp) { +return ;if (xfs_set_inodegc_enabled (mp))return ;@@ -2180,6 +2181,12 @@ xfs_inodegc_queue( ip->i_flags |=XFS_NEED_INACTIVE ;spin_unlock (&ip->i_flags_lock);
Quoted 10 lines
fs/xfs/xfs_icache.c xfs_inodegc_queue( · line 2188
Quoted 5 lines
fs/xfs/xfs_icache.c +5
-0+if (1 ) { +xfs_iflags_set (ip,XFS_INACTIVATING ); +xfs_inodegc_inactivate (ip); +return ; + }That reintroduces potential deadlock vectors by running blocking transactions directly from
iput()and/or memory reclaim. That's one of the main reasons we moved inactivation to a background thread - it gets rid of an entire class of potential deadlock problems....
Yeah, I noticed that too, mainly
commit 68b957f64fca ("xfs: load uncached unlinked inodes into memory on demand").
Thanks,
Gao Xiang
Quoted 2 lines
-Dave.
Quoted 29 lines · Gao Xiang
Hi Dave,
Quoted 17 lines · Dave Chinner
Quoted 8 lines · Gao Xiang
Hi folks,
Days ago, I received a XFS Unixbench[1] shell1 (high-concurrency) performance regression during a benchmark comparison between XFS and
EXT4: The XFS result was lower than EXT4 by 15% on Linux 6.6.y with 144-core aarch64 (64K page size). Since Unixbench is somewhat important to indicate overall system performance for many end users, it's not a good result.Unixbench isn't really that indicative of typical worklaods on large core-count machines these days. It's an ancient benchmark, and it's exceedingly rare that a modern machine is fully loaded with shell scripts such as the shell1 test is running because it's highly inefficient to do large scale concurrent processing of data in this way....
Quoted 8 lines
Indeed, look at the file copy "benchmarks" it runs - the use buffer sizes of 256, 1024 and 4096 bytes to tell you how well the filesystem performs. Using sub-page size buffers might have been common for 1983-era CPUs to get the highest possible file copy throughput, but these days these are slow paths that we largely don't optimise for highest throughput. Measuring modern system scalability via how such operations perform is largely meaningless because applications don't behave this way anymore....
Quoted 4 lines
Thanks for your reply!
Sigh. Many customers really care, and they select the whole software stack based on this benchmark.
People using benchmarks that have no relevance to their software/application stack behaviour as the basis of their purchase decisions has been happening for decades.
Quoted 2 lines
If they think the results are not good, they might ask us to move away of XFS filesystem. It's not what I could do anything, you know.
If they think there is a filesystem better suited to their requirements than XFS, then they are free to make that decision themselves. We can point out that their selection metrics are irrelevant to their actual workload, but in my experience this just makes the people running the selection trial more convinced they are right and they still make a poor decision....
Quoted 11 lines
Quoted 11 lines
Quoted 7 lines
shell1 test[2] basically runs in a loop that it executes commands to generate files (sort.$$, od.$$, grep.$$, wc.$$) and then remove them. The testcase lasts for one minute and then show the total number of iterations.
While no difference was observed in single-threaded results, it showed a noticeable difference above if
./Run shell1 -c 144 -i 1is used.I'm betting that the XFS filesystem is small and only has 4 AGs, and so has very limited concurrency in allocation.
Quoted 6 lines
Quoted 4 lines
i.e. you're trying to run a massively concurrent workload on a filesystem that only has - at best - the ability to do 4 allocations or frees at a time. Of course it is going to contend on the allocation group locks....
I've adjusted this, from 4 AG to 20 AG. No real impact.
Yup, still very limited concurrency considering that you are running 144 instances of that workload (which, AFAICT, are all doing independent work). This implies that a couple of hundred AGs would be needed to provide sufficient allocation concurrency for this sort of workload.
Quoted 30 lines
Quoted 19 lines
Quoted 19 lines
I tried to do some hack to disable defer inode inactivation as below, the shell1 benchmark then recovered: XFS (35649.6 -> 37810.9):
fs/xfs/xfs_icache.c +1
-0@@ -2059,6 +2059,7 @@ voidxfs_inodegc_start ( struct xfs_mount *mp) { +return ;if (xfs_set_inodegc_enabled (mp))return ;@@ -2180,6 +2181,12 @@ xfs_inodegc_queue( ip->i_flags |=XFS_NEED_INACTIVE ;spin_unlock (&ip->i_flags_lock);Quoted 10 lines
fs/xfs/xfs_icache.c xfs_inodegc_queue( · line 2188
Quoted 5 lines
fs/xfs/xfs_icache.c +5
-0+if (1 ) { +xfs_iflags_set (ip,XFS_INACTIVATING ); +xfs_inodegc_inactivate (ip); +return ; + }That reintroduces potential deadlock vectors by running blocking transactions directly from
iput()and/or memory reclaim. That's one of the main reasons we moved inactivation to a background thread - it gets rid of an entire class of potential deadlock problems....
Quoted 3 lines
Yeah, I noticed that too, mainly
commit68b957f64fca("xfs: load uncached unlinked inodes into memory on demand").
That is not related to the class of deadlocks and issues I'm referring to. Running a transaction in memory reclaim context (i.e. shrinker evicts the inode from memory) means that memory reclaim now blocks on journal space, IO, buffer locks, etc.
The sort of deadlock that this can cause is a non-transactional operation above memory reclaim holding a buffer lock (e.g. bulkstat reading the AGI btree), then requiring memory allocation (e.g. pulling a AGI btree block into memory) which triggers direct memory reclaim, which then tries to inactivate an inode, which then (for whatever reason) requires taking a AGI btree block lock....
That is the class of potential deadlock that background inode inactivation avoids completely. It also avoids excessive inode eviction latency (important as shrinkers run from direct reclaim are supposed to be non-blocking) and other sub-optimal inode eviction behaviours from occurring...
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Quoted 30 lines · Dave Chinner
Quoted 29 lines · Gao Xiang
Hi Dave,
Quoted 25 lines · Dave Chinner
Quoted 8 lines · Gao Xiang
Hi folks,
Days ago, I received a XFS Unixbench[1] shell1 (high-concurrency) performance regression during a benchmark comparison between XFS and
EXT4: The XFS result was lower than EXT4 by 15% on Linux 6.6.y with 144-core aarch64 (64K page size). Since Unixbench is somewhat important to indicate overall system performance for many end users, it's not a good result.Unixbench isn't really that indicative of typical worklaods on large core-count machines these days. It's an ancient benchmark, and it's exceedingly rare that a modern machine is fully loaded with shell scripts such as the shell1 test is running because it's highly inefficient to do large scale concurrent processing of data in this way....
Indeed, look at the file copy "benchmarks" it runs - the use buffer sizes of 256, 1024 and 4096 bytes to tell you how well the filesystem performs. Using sub-page size buffers might have been common for 1983-era CPUs to get the highest possible file copy throughput, but these days these are slow paths that we largely don't optimise for highest throughput. Measuring modern system scalability via how such operations perform is largely meaningless because applications don't behave this way anymore....
Quoted 8 lines
Quoted 4 lines
Thanks for your reply!
Sigh. Many customers really care, and they select the whole software stack based on this benchmark.
People using benchmarks that have no relevance to their software/application stack behaviour as the basis of their purchase decisions has been happening for decades.
They even know nothing. Unixbench is already a practice for them, I cannot argue about that.
Quoted 10 lines
Quoted 3 lines
If they think the results are not good, they might ask us to move away of XFS filesystem. It's not what I could do anything, you know.
If they think there is a filesystem better suited to their requirements than XFS, then they are free to make that decision themselves. We can point out that their selection metrics are irrelevant to their actual workload, but in my experience this just makes the people running the selection trial more convinced they are right and they still make a poor decision....
The problem is not simple like this, what we'd like is to provide a unique cloud image for users to use. It's impossible for us to provide two images for two filesystems. But Unixbench is still important for many users, so either we still to XFS or switch back to EXT4.
Quoted 17 lines
Quoted 17 lines
Quoted 16 lines
Quoted 8 lines
shell1 test[2] basically runs in a loop that it executes commands to generate files (sort.$$, od.$$, grep.$$, wc.$$) and then remove them. The testcase lasts for one minute and then show the total number of iterations.
While no difference was observed in single-threaded results, it showed a noticeable difference above if
./Run shell1 -c 144 -i 1is used.I'm betting that the XFS filesystem is small and only has 4 AGs, and so has very limited concurrency in allocation.
i.e. you're trying to run a massively concurrent workload on a filesystem that only has - at best - the ability to do 4 allocations or frees at a time. Of course it is going to contend on the allocation group locks....
Quoted 7 lines
Quoted 1 line
I've adjusted this, from 4 AG to 20 AG. No real impact.
Yup, still very limited concurrency considering that you are running 144 instances of that workload (which, AFAICT, are all doing independent work). This implies that a couple of hundred AGs would be needed to provide sufficient allocation concurrency for this sort of workload.
Hmm.. We shipped a unique traditional rootfs image to all users, we cannot adjust AG numbers according to specific workload like this because increasing AG numbers is not always good for many other workloads.
But I could try to use 144 AG and retest again.
Quoted 40 lines
Quoted 31 lines
Quoted 20 lines
Quoted 20 lines
I tried to do some hack to disable defer inode inactivation as below, the shell1 benchmark then recovered: XFS (35649.6 -> 37810.9):
fs/xfs/xfs_icache.c +1
-0@@ -2059,6 +2059,7 @@ voidxfs_inodegc_start ( struct xfs_mount *mp) { +return ;if (xfs_set_inodegc_enabled (mp))return ;@@ -2180,6 +2181,12 @@ xfs_inodegc_queue( ip->i_flags |=XFS_NEED_INACTIVE ;spin_unlock (&ip->i_flags_lock);Quoted 10 lines
fs/xfs/xfs_icache.c xfs_inodegc_queue( · line 2188
Quoted 5 lines
fs/xfs/xfs_icache.c +5
-0+if (1 ) { +xfs_iflags_set (ip,XFS_INACTIVATING ); +xfs_inodegc_inactivate (ip); +return ; + }That reintroduces potential deadlock vectors by running blocking transactions directly from
iput()and/or memory reclaim. That's one of the main reasons we moved inactivation to a background thread - it gets rid of an entire class of potential deadlock problems....Quoted 3 lines
Yeah, I noticed that too, mainly
commit68b957f64fca("xfs: load uncached unlinked inodes into memory on demand").That is not related to the class of deadlocks and issues I'm referring to. Running a transaction in memory reclaim context (i.e. shrinker evicts the inode from memory) means that memory reclaim now blocks on journal space, IO, buffer locks, etc.
Quoted 6 lines
The sort of deadlock that this can cause is a non-transactional operation above memory reclaim holding a buffer lock (e.g. bulkstat reading the AGI btree), then requiring memory allocation (e.g. pulling a AGI btree block into memory) which triggers direct memory reclaim, which then tries to inactivate an inode, which then (for whatever reason) requires taking a AGI btree block lock....
Yeah, we don't have a context to know AGI lock is locked before.
Quoted 6 lines
That is the class of potential deadlock that background inode inactivation avoids completely. It also avoids excessive inode eviction latency (important as shrinkers run from direct reclaim are supposed to be non-blocking) and other sub-optimal inode eviction behaviours from occurring...
I know, what I meant was a direct problem if I hack to revert to the old way even I don't care about the memory reclaim deadlock.
It seems the in-core unlink list is heavily relied on this feature too, so I don't have a good way anyway.
Thanks,
Gao Xiang
Quoted 2 lines
-Dave.
Quoted 12 lines · Gao Xiang
Quoted 10 lines · Dave Chinner
Quoted 2 lines · Gao Xiang
If they think the results are not good, they might ask us to move away of XFS filesystem. It's not what I could do anything, you know.
If they think there is a filesystem better suited to their requirements than XFS, then they are free to make that decision themselves. We can point out that their selection metrics are irrelevant to their actual workload, but in my experience this just makes the people running the selection trial more convinced they are right and they still make a poor decision....
Quoted 5 lines
The problem is not simple like this, what we'd like is to provide a unique cloud image for users to use. It's impossible for us to provide two images for two filesystems. But Unixbench is still important for many users, so either we still to XFS or switch back to EXT4.
Well, that means your company has the motivation to try to improve the XFS code, doesn't it? If they won't put up the resources to address issues that affect their customers, then why should anyone else do that work for them for free?
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Quoted 19 lines · Dave Chinner
Quoted 12 lines · Gao Xiang
Quoted 10 lines · Dave Chinner
Quoted 2 lines · Gao Xiang
If they think the results are not good, they might ask us to move away of XFS filesystem. It's not what I could do anything, you know.
If they think there is a filesystem better suited to their requirements than XFS, then they are free to make that decision themselves. We can point out that their selection metrics are irrelevant to their actual workload, but in my experience this just makes the people running the selection trial more convinced they are right and they still make a poor decision....
Quoted 5 lines
The problem is not simple like this, what we'd like is to provide a unique cloud image for users to use. It's impossible for us to provide two images for two filesystems. But Unixbench is still important for many users, so either we still to XFS or switch back to EXT4.
Quoted 4 lines
Well, that means your company has the motivation to try to improve the XFS code, doesn't it? If they won't put up the resources to address issues that affect their customers, then why should anyone else do that work for them for free?
Disclose: I don't speak for my company. So the following is just my own thoughts.
It may be true in 2023, however, the only resource now is me (I suspect there will be more resource), but I still have other work to do on my hand which impacts my own performance review more. For this issue, I spent much time (up to the mid-night) last week to find out, which greatly impact my own physical health. Yes, I will speed more on this, but:
There is no clear evidence that a cloud image could directly benefit to our AI infra. So from POV of a company, the worst case is that they may revisit the overall benefits among all possible choices and find out the best one.
Anyway, I've got the community view of Unixbench. I will arrange my own TODO list.
Thanks,
Gao Xiang
Quoted 5 lines
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Quoted 2 lines · Gao Xiang
Anyway, I've got the community view of Unixbench. I will arrange my own TODO list.
FYI, while I agree with all of Dave's observation on Unixbench I don't entirely agree with the conclusion. Yes, we should not bend over backwards to optimize for this workload. But if we can find an easy enough way to improve it I'm all in favour. While everyone should know not to do subsector writes there's actually still plenty of workloads that do. And while those are not the heavily optimized ones that really matter it would still be nice to get good numbers for them.
So if you can find a way to optimize it without much negative impact I'd love to see that.
Hi Christoph,
Quoted 12 lines · Christoph Hellwig
Quoted 2 lines · Gao Xiang
Anyway, I've got the community view of Unixbench. I will arrange my own TODO list.
FYI, while I agree with all of Dave's observation on Unixbench I don't entirely agree with the conclusion. Yes, we should not bend over backwards to optimize for this workload. But if we can find an easy enough way to improve it I'm all in favour. While everyone should know not to do subsector writes there's actually still plenty of workloads that do. And while those are not the heavily optimized ones that really matter it would still be nice to get good numbers for them.
Quoted 2 lines
So if you can find a way to optimize it without much negative impact I'd love to see that.
Got it. I will find time digging into more (but honestly, the priority is not high), if there could be some clean solution, I will feedback then.
BTW, if any folks are really interested in this case and get much high priority compared to me (that is one of reasons I reported it immediately), I really appreciate too.
Thanks,
Gao Xiang