* [PATCH 0/3] lib/raid6: Optimize raid6_select_algo while ensuring
@ 2026-01-28 10:49 sunliming
2026-01-28 10:49 ` [PATCH 1/3] lib/raid6: Divide the raid6 algorithm selection process into two parts sunliming
` (2 more replies)
0 siblings, 3 replies; 6+ messages in thread
From: sunliming @ 2026-01-28 10:49 UTC (permalink / raw)
To: song, yukuai; +Cc: linux-raid, linux-kernel, sunliming
From: sunliming <sunliming@kylinos.cn>
The selection of RAID6 PQ functions involves a dual-strategy approach:
prioritizing startup speed leads to quickly choosing a usable algorithm,
while prioritizing performance leads to selecting an optimal algorithm
via benchmarking. This choice is determined by the RAID6_PQ_BENCHMARK
configuration. This patch series achieves both fast startup and optimal
algorithm selection by initially choosing an algorithm quickly at startup,
then asynchronously determining the optimal algorithm through benchmarking.
Since all RAID6 PQ function algorithms are functionally equivalent despite
performance differences, this approach should be effective.
sunliming (3):
lib/raid6: Divide the raid6 algorithm selection process into two parts
lib/raid6: Optimizing the raid6_select_algo time through asynchronous
processing
lib/raid6: Delete the RAID6_PQ_BENCHMARK config
lib/Kconfig | 8 -----
lib/raid6/algos.c | 92 +++++++++++++++++++++++++++++++----------------
2 files changed, 61 insertions(+), 39 deletions(-)
--
2.25.1
^ permalink raw reply [flat|nested] 6+ messages in thread* [PATCH 1/3] lib/raid6: Divide the raid6 algorithm selection process into two parts 2026-01-28 10:49 [PATCH 0/3] lib/raid6: Optimize raid6_select_algo while ensuring sunliming @ 2026-01-28 10:49 ` sunliming 2026-01-29 3:26 ` Li Nan 2026-01-28 10:49 ` [PATCH 2/3] lib/raid6: Optimizing the raid6_select_algo time through asynchronous processing sunliming 2026-01-28 10:49 ` [PATCH 3/3] lib/raid6: Delete the RAID6_PQ_BENCHMARK config sunliming 2 siblings, 1 reply; 6+ messages in thread From: sunliming @ 2026-01-28 10:49 UTC (permalink / raw) To: song, yukuai; +Cc: linux-raid, linux-kernel, sunliming From: sunliming <sunliming@kylinos.cn> Divide the RAID6 algorithm selection process into two parts: fast selection and benchmark selection. To prepare for the asynchronous processing of the benchmark phase. Signed-off-by: sunliming <sunliming@kylinos.cn> --- lib/raid6/algos.c | 76 +++++++++++++++++++++++++++++++---------------- 1 file changed, 51 insertions(+), 25 deletions(-) diff --git a/lib/raid6/algos.c b/lib/raid6/algos.c index 799e0e5eac26..ac6a77b0ae1d 100644 --- a/lib/raid6/algos.c +++ b/lib/raid6/algos.c @@ -134,7 +134,7 @@ const struct raid6_recov_calls *const raid6_recov_algos[] = { static inline const struct raid6_recov_calls *raid6_choose_recov(void) { const struct raid6_recov_calls *const *algo; - const struct raid6_recov_calls *best; + const struct raid6_recov_calls *best = NULL; for (best = NULL, algo = raid6_recov_algos; *algo; algo++) if (!best || (*algo)->priority > best->priority) @@ -152,24 +152,44 @@ static inline const struct raid6_recov_calls *raid6_choose_recov(void) return best; } -static inline const struct raid6_calls *raid6_choose_gen( - void *(*const dptrs)[RAID6_TEST_DISKS], const int disks) +/* Quick selection: selects the first valid algorithm. */ +static inline const struct raid6_calls *raid6_choose_gen_fast(void) +{ + const struct raid6_calls *const *algo; + const struct raid6_calls *best = NULL; + + for (algo = raid6_algos; *algo; algo++) { + if ((*algo)->valid && !(*algo)->valid()) + continue; + + best = *algo; + break; + } + + if (best) { + raid6_call = *best; + pr_info("raid6: skipped pq benchmark and selected %s\n", + best->name); + } else { + pr_err("raid6: No valid algorithm found even for fast selection!\n"); + } + + return best; +} + +static inline const struct raid6_calls *raid6_gen_benchmark( + void *(*const dptrs)[RAID6_TEST_DISKS], const int disks) { unsigned long perf, bestgenperf, j0, j1; int start = (disks>>1)-1, stop = disks-3; /* work on the second half of the disks */ const struct raid6_calls *const *algo; - const struct raid6_calls *best; + const struct raid6_calls *best = NULL; for (bestgenperf = 0, best = NULL, algo = raid6_algos; *algo; algo++) { if (!best || (*algo)->priority >= best->priority) { if ((*algo)->valid && !(*algo)->valid()) continue; - if (!IS_ENABLED(CONFIG_RAID6_PQ_BENCHMARK)) { - best = *algo; - break; - } - perf = 0; preempt_disable(); @@ -200,12 +220,6 @@ static inline const struct raid6_calls *raid6_choose_gen( raid6_call = *best; - if (!IS_ENABLED(CONFIG_RAID6_PQ_BENCHMARK)) { - pr_info("raid6: skipped pq benchmark and selected %s\n", - best->name); - goto out; - } - pr_info("raid6: using algorithm %s gen() %ld MB/s\n", best->name, (bestgenperf * HZ * (disks - 2)) >> @@ -235,16 +249,11 @@ static inline const struct raid6_calls *raid6_choose_gen( return best; } - /* Try to pick the best algorithm */ /* This code uses the gfmul table as convenient data set to abuse */ - -int __init raid6_select_algo(void) +static int raid6_choose_gen_benmark(const struct raid6_calls **gen_best) { const int disks = RAID6_TEST_DISKS; - - const struct raid6_calls *gen_best; - const struct raid6_recov_calls *rec_best; char *disk_ptr, *p; void *dptrs[RAID6_TEST_DISKS]; int i, cycle; @@ -269,14 +278,31 @@ int __init raid6_select_algo(void) if ((disks - 2) * PAGE_SIZE % 65536) memcpy(p, raid6_gfmul, (disks - 2) * PAGE_SIZE % 65536); - /* select raid gen_syndrome function */ - gen_best = raid6_choose_gen(&dptrs, disks); + *gen_best = raid6_gen_benchmark(&dptrs, disks); + + free_pages((unsigned long)disk_ptr, RAID6_TEST_DISKS_ORDER); + + return 0; +} + +int __init raid6_select_algo(void) +{ + int ret; + const struct raid6_calls *gen_best = NULL; + const struct raid6_recov_calls *rec_best = NULL; + + /* select raid gen_syndrome functions */ + if (!IS_ENABLED(CONFIG_RAID6_PQ_BENCHMARK)) + gen_best = raid6_choose_gen_fast(); + else { + ret = raid6_choose_gen_benmark(&gen_best); + if (ret < 0) + return ret; + } /* select raid recover functions */ rec_best = raid6_choose_recov(); - free_pages((unsigned long)disk_ptr, RAID6_TEST_DISKS_ORDER); - return gen_best && rec_best ? 0 : -EINVAL; } -- 2.25.1 ^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH 1/3] lib/raid6: Divide the raid6 algorithm selection process into two parts 2026-01-28 10:49 ` [PATCH 1/3] lib/raid6: Divide the raid6 algorithm selection process into two parts sunliming @ 2026-01-29 3:26 ` Li Nan 0 siblings, 0 replies; 6+ messages in thread From: Li Nan @ 2026-01-29 3:26 UTC (permalink / raw) To: sunliming, song, yukuai; +Cc: linux-raid, linux-kernel, sunliming 在 2026/1/28 18:49, sunliming@linux.dev 写道: > From: sunliming <sunliming@kylinos.cn> > > Divide the RAID6 algorithm selection process into two parts: fast selection > and benchmark selection. To prepare for the asynchronous processing of > the benchmark phase. > > Signed-off-by: sunliming <sunliming@kylinos.cn> > --- > lib/raid6/algos.c | 76 +++++++++++++++++++++++++++++++---------------- > 1 file changed, 51 insertions(+), 25 deletions(-) > > diff --git a/lib/raid6/algos.c b/lib/raid6/algos.c > index 799e0e5eac26..ac6a77b0ae1d 100644 > --- a/lib/raid6/algos.c > +++ b/lib/raid6/algos.c > @@ -134,7 +134,7 @@ const struct raid6_recov_calls *const raid6_recov_algos[] = { > static inline const struct raid6_recov_calls *raid6_choose_recov(void) > { > const struct raid6_recov_calls *const *algo; > - const struct raid6_recov_calls *best; > + const struct raid6_recov_calls *best = NULL; > > for (best = NULL, algo = raid6_recov_algos; *algo; algo++) > if (!best || (*algo)->priority > best->priority) > @@ -152,24 +152,44 @@ static inline const struct raid6_recov_calls *raid6_choose_recov(void) > return best; > } > > -static inline const struct raid6_calls *raid6_choose_gen( > - void *(*const dptrs)[RAID6_TEST_DISKS], const int disks) > +/* Quick selection: selects the first valid algorithm. */ > +static inline const struct raid6_calls *raid6_choose_gen_fast(void) > +{ > + const struct raid6_calls *const *algo; > + const struct raid6_calls *best = NULL; > + > + for (algo = raid6_algos; *algo; algo++) { > + if ((*algo)->valid && !(*algo)->valid()) > + continue; This logic is odd. We should select the highest-priority algorithm instead of the first one. This was introduced by commit be85f93ae2df ("lib/raid6: add option to skip algorithm benchmarking"). After fix, this logic is identical to raid6_choose_recov(). Could we reuse it after renaming the function? > + > + best = *algo; > + break; > + } > + > + if (best) { > + raid6_call = *best; > + pr_info("raid6: skipped pq benchmark and selected %s\n", > + best->name); > + } else { > + pr_err("raid6: No valid algorithm found even for fast selection!\n"); > + } > + > + return best; > +} > + > +static inline const struct raid6_calls *raid6_gen_benchmark( > + void *(*const dptrs)[RAID6_TEST_DISKS], const int disks) > { > unsigned long perf, bestgenperf, j0, j1; > int start = (disks>>1)-1, stop = disks-3; /* work on the second half of the disks */ > const struct raid6_calls *const *algo; > - const struct raid6_calls *best; > + const struct raid6_calls *best = NULL; > > for (bestgenperf = 0, best = NULL, algo = raid6_algos; *algo; algo++) { > if (!best || (*algo)->priority >= best->priority) { > if ((*algo)->valid && !(*algo)->valid()) > continue; > > - if (!IS_ENABLED(CONFIG_RAID6_PQ_BENCHMARK)) { > - best = *algo; > - break; > - } > - > perf = 0; > > preempt_disable(); > @@ -200,12 +220,6 @@ static inline const struct raid6_calls *raid6_choose_gen( > > raid6_call = *best; > > - if (!IS_ENABLED(CONFIG_RAID6_PQ_BENCHMARK)) { > - pr_info("raid6: skipped pq benchmark and selected %s\n", > - best->name); > - goto out; > - } > - > pr_info("raid6: using algorithm %s gen() %ld MB/s\n", > best->name, > (bestgenperf * HZ * (disks - 2)) >> > @@ -235,16 +249,11 @@ static inline const struct raid6_calls *raid6_choose_gen( > return best; > } > > - > /* Try to pick the best algorithm */ > /* This code uses the gfmul table as convenient data set to abuse */ > - > -int __init raid6_select_algo(void) > +static int raid6_choose_gen_benmark(const struct raid6_calls **gen_best) > { > const int disks = RAID6_TEST_DISKS; > - > - const struct raid6_calls *gen_best; > - const struct raid6_recov_calls *rec_best; > char *disk_ptr, *p; > void *dptrs[RAID6_TEST_DISKS]; > int i, cycle; > @@ -269,14 +278,31 @@ int __init raid6_select_algo(void) > if ((disks - 2) * PAGE_SIZE % 65536) > memcpy(p, raid6_gfmul, (disks - 2) * PAGE_SIZE % 65536); > > - /* select raid gen_syndrome function */ > - gen_best = raid6_choose_gen(&dptrs, disks); > + *gen_best = raid6_gen_benchmark(&dptrs, disks); > + > + free_pages((unsigned long)disk_ptr, RAID6_TEST_DISKS_ORDER); > + > + return 0; > +} > + > +int __init raid6_select_algo(void) > +{ > + int ret; > + const struct raid6_calls *gen_best = NULL; > + const struct raid6_recov_calls *rec_best = NULL; > + > + /* select raid gen_syndrome functions */ > + if (!IS_ENABLED(CONFIG_RAID6_PQ_BENCHMARK)) > + gen_best = raid6_choose_gen_fast(); > + else { > + ret = raid6_choose_gen_benmark(&gen_best); 'gen_best' is meaningless, use 'ret' directly. The input parameter of raid6_choose_gen_benchmark() can be modified to void. > + if (ret < 0) > + return ret; > + } > > /* select raid recover functions */ > rec_best = raid6_choose_recov(); > > - free_pages((unsigned long)disk_ptr, RAID6_TEST_DISKS_ORDER); > - > return gen_best && rec_best ? 0 : -EINVAL; > } > -- Thanks, Nan ^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 2/3] lib/raid6: Optimizing the raid6_select_algo time through asynchronous processing 2026-01-28 10:49 [PATCH 0/3] lib/raid6: Optimize raid6_select_algo while ensuring sunliming 2026-01-28 10:49 ` [PATCH 1/3] lib/raid6: Divide the raid6 algorithm selection process into two parts sunliming @ 2026-01-28 10:49 ` sunliming 2026-02-03 13:54 ` kernel test robot 2026-01-28 10:49 ` [PATCH 3/3] lib/raid6: Delete the RAID6_PQ_BENCHMARK config sunliming 2 siblings, 1 reply; 6+ messages in thread From: sunliming @ 2026-01-28 10:49 UTC (permalink / raw) To: song, yukuai; +Cc: linux-raid, linux-kernel, sunliming From: sunliming <sunliming@kylinos.cn> Optimizing the raid6_select_algo time. In raid6_select_algo(), an raid6 gen algorithm is first selected quickly through synchronous processing, while the time-consuming process of selecting the optimal algorithm via benchmarking is handled asynchronously. This approach speeds up the overall startup time and ultimately ensures the selection of an optimal algorithm. Signed-off-by: sunliming <sunliming@kylinos.cn> --- lib/raid6/algos.c | 44 ++++++++++++++++++++++++-------------------- 1 file changed, 24 insertions(+), 20 deletions(-) diff --git a/lib/raid6/algos.c b/lib/raid6/algos.c index ac6a77b0ae1d..c92168d59df2 100644 --- a/lib/raid6/algos.c +++ b/lib/raid6/algos.c @@ -12,6 +12,7 @@ */ #include <linux/raid/pq.h> +#include <linux/workqueue.h> #ifndef __KERNEL__ #include <sys/mman.h> #include <stdio.h> @@ -168,7 +169,7 @@ static inline const struct raid6_calls *raid6_choose_gen_fast(void) if (best) { raid6_call = *best; - pr_info("raid6: skipped pq benchmark and selected %s\n", + pr_info("raid6: fast selected %s, async benchmark pending\n", best->name); } else { pr_err("raid6: No valid algorithm found even for fast selection!\n"); @@ -177,7 +178,7 @@ static inline const struct raid6_calls *raid6_choose_gen_fast(void) return best; } -static inline const struct raid6_calls *raid6_gen_benchmark( +static inline void raid6_gen_benchmark( void *(*const dptrs)[RAID6_TEST_DISKS], const int disks) { unsigned long perf, bestgenperf, j0, j1; @@ -214,12 +215,11 @@ static inline const struct raid6_calls *raid6_gen_benchmark( } if (!best) { - pr_err("raid6: Yikes! No algorithm found!\n"); - goto out; + pr_err("raid6: async benchmark failed to find any algorithm\n"); + return; } raid6_call = *best; - pr_info("raid6: using algorithm %s gen() %ld MB/s\n", best->name, (bestgenperf * HZ * (disks - 2)) >> @@ -244,14 +244,11 @@ static inline const struct raid6_calls *raid6_gen_benchmark( (perf * HZ * (disks - 2)) >> (20 - PAGE_SHIFT + RAID6_TIME_JIFFIES_LG2 + 1)); } - -out: - return best; } /* Try to pick the best algorithm */ /* This code uses the gfmul table as convenient data set to abuse */ -static int raid6_choose_gen_benmark(const struct raid6_calls **gen_best) +static int raid6_choose_gen_benmark(void) { const int disks = RAID6_TEST_DISKS; char *disk_ptr, *p; @@ -278,32 +275,39 @@ static int raid6_choose_gen_benmark(const struct raid6_calls **gen_best) if ((disks - 2) * PAGE_SIZE % 65536) memcpy(p, raid6_gfmul, (disks - 2) * PAGE_SIZE % 65536); - *gen_best = raid6_gen_benchmark(&dptrs, disks); + raid6_gen_benchmark(&dptrs, disks); free_pages((unsigned long)disk_ptr, RAID6_TEST_DISKS_ORDER); return 0; } +static struct work_struct raid6_benchmark_work __initdata; + +static __init void benchmark_work_func(struct work_struct *work) +{ + raid6_choose_gen_benmark(); +} + int __init raid6_select_algo(void) { - int ret; const struct raid6_calls *gen_best = NULL; const struct raid6_recov_calls *rec_best = NULL; - /* select raid gen_syndrome functions */ - if (!IS_ENABLED(CONFIG_RAID6_PQ_BENCHMARK)) - gen_best = raid6_choose_gen_fast(); - else { - ret = raid6_choose_gen_benmark(&gen_best); - if (ret < 0) - return ret; - } + /* phase 1: synchronous fast selection generation algorithm */ + gen_best = raid6_choose_gen_fast(); /* select raid recover functions */ rec_best = raid6_choose_recov(); - return gen_best && rec_best ? 0 : -EINVAL; + if (!gen_best || !rec_best) + return -EINVAL; + + /* phase 2: asynchronous performance benchmarking */ + INIT_WORK(&raid6_benchmark_work, benchmark_work_func); + schedule_work(&raid6_benchmark_work); + + return 0; } static void raid6_exit(void) -- 2.25.1 ^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH 2/3] lib/raid6: Optimizing the raid6_select_algo time through asynchronous processing 2026-01-28 10:49 ` [PATCH 2/3] lib/raid6: Optimizing the raid6_select_algo time through asynchronous processing sunliming @ 2026-02-03 13:54 ` kernel test robot 0 siblings, 0 replies; 6+ messages in thread From: kernel test robot @ 2026-02-03 13:54 UTC (permalink / raw) To: sunliming Cc: oe-lkp, lkp, linux-raid, song, yukuai, linux-kernel, sunliming, oliver.sang Hello, kernel test robot noticed "Oops:int3:#[##]SMP_KASAN_NOPTI" on: commit: e806b74f91ad2c995a3313d4cc369c85fab1da5f ("[PATCH 2/3] lib/raid6: Optimizing the raid6_select_algo time through asynchronous processing") url: https://github.com/intel-lab-lkp/linux/commits/sunliming-linux-dev/lib-raid6-Divide-the-raid6-algorithm-selection-process-into-two-parts/20260128-185709 base: https://git.kernel.org/cgit/linux/kernel/git/akpm/mm.git mm-nonmm-unstable patch link: https://lore.kernel.org/all/20260128104923.338443-3-sunliming@linux.dev/ patch subject: [PATCH 2/3] lib/raid6: Optimizing the raid6_select_algo time through asynchronous processing in testcase: perf-sanity-tests version: with following parameters: perf_compiler: gcc group: group-01 config: x86_64-rhel-9.4-bpf compiler: gcc-14 test machine: 16 threads 1 sockets Intel(R) Xeon(R) E-2278G CPU @ 3.40GHz (Coffee Lake-E) with 32G memory (please refer to attached dmesg/kmsg for entire log/backtrace) If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags | Reported-by: kernel test robot <oliver.sang@intel.com> | Closes: https://lore.kernel.org/oe-lkp/202602032100.d8e49b6f-lkp@intel.com [ 81.117339][ T479] xor: automatically using best checksumming function avx [ 81.122258][ T109] raid6: avx2x2 gen() 17654 MB/s [ 81.157936][ T109] raid6: avx2x1 gen() 10371 MB/s [ 81.172813][ T109] raid6: using algorithm avx2x2 gen() 17654 MB/s [ 81.205659][ T109] raid6: .... xor() 12927 MB/s, rmw enabled [ 81.221136][ C15] Oops: int3: 0000 [#1] SMP KASAN NOPTI [ 81.221144][ C15] CPU: 15 UID: 0 PID: 109 Comm: kworker/15:0 Tainted: G S 6.19.0-rc6-00161-ge806b74f91ad #1 PREEMPT(full) [ 81.221149][ C15] Tainted: [S]=CPU_OUT_OF_SPEC [ 81.221150][ C15] Hardware name: Intel Corporation Mehlow UP Server Platform/Moss Beach Server, BIOS CNLSE2R1.R00.X188.B13.1903250419 03/25/2019 [ 81.221153][ C15] Workqueue: events benchmark_work_func [raid6_pq] [ 81.221160][ C15] RIP: 0010:benchmark_work_func (recov_avx512.c:?) raid6_pq [ 81.221163][ C15] Code: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc <cc> cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc All code ======== 0: cc int3 1: cc int3 2: cc int3 3: cc int3 4: cc int3 5: cc int3 6: cc int3 7: cc int3 8: cc int3 9: cc int3 a: cc int3 b: cc int3 c: cc int3 d: cc int3 e: cc int3 f: cc int3 10: cc int3 11: cc int3 12: cc int3 13: cc int3 14: cc int3 15: cc int3 16: cc int3 17: cc int3 18: cc int3 19: cc int3 1a: cc int3 1b: cc int3 1c: cc int3 1d: cc int3 1e: cc int3 1f: cc int3 20: cc int3 21: cc int3 22: cc int3 23: cc int3 24: cc int3 25: cc int3 26: cc int3 27: cc int3 28: cc int3 29: cc int3 2a:* cc int3 <-- trapping instruction 2b: cc int3 2c: cc int3 2d: cc int3 2e: cc int3 2f: cc int3 30: cc int3 31: cc int3 32: cc int3 33: cc int3 34: cc int3 35: cc int3 36: cc int3 37: cc int3 38: cc int3 39: cc int3 3a: cc int3 3b: cc int3 3c: cc int3 3d: cc int3 3e: cc int3 3f: cc int3 Code starting with the faulting instruction =========================================== 0: cc int3 1: cc int3 2: cc int3 3: cc int3 4: cc int3 5: cc int3 6: cc int3 7: cc int3 8: cc int3 9: cc int3 a: cc int3 b: cc int3 c: cc int3 d: cc int3 e: cc int3 f: cc int3 10: cc int3 11: cc int3 12: cc int3 13: cc int3 14: cc int3 15: cc int3 [ 81.221166][ C15] RSP: 0018:ffff888101557b58 EFLAGS: 00000282 [ 81.221169][ C15] RAX: 0000000000000029 RBX: 1ffff110202aaf6b RCX: 0000000000000000 [ 81.221171][ C15] RDX: 0000000000000029 RSI: ffffffff81513d9c RDI: ffffed10202aaf5e [ 81.221173][ C15] RBP: ffff88836aad0000 R08: 0000000000000000 R09: fffffbfff0b21df4 [ 81.221175][ C15] R10: ffffffff8590efa7 R11: 0000000000000001 R12: ffff888101557bb8 [ 81.221178][ C15] R13: ffff88836aad8000 R14: ffff888101557bb8 R15: ffff8887887c33c0 [ 81.221180][ C15] FS: 0000000000000000(0000) GS:ffff888801e6a000(0000) knlGS:0000000000000000 [ 81.221182][ C15] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 81.221185][ C15] CR2: 00007fbfb077d000 CR3: 000000084d2f6001 CR4: 00000000003726f0 [ 81.221187][ C15] Call Trace: [ 81.221189][ C15] <TASK> [ 81.221194][ C15] ? rcu_is_watching (kbuild/src/consumer/arch/x86/include/asm/atomic.h:23 kbuild/src/consumer/include/linux/atomic/atomic-arch-fallback.h:457 kbuild/src/consumer/include/linux/context_tracking.h:128 kbuild/src/consumer/kernel/rcu/tree.c:751) [ 81.221199][ C15] ? rcu_is_watching (kbuild/src/consumer/arch/x86/include/asm/atomic.h:23 kbuild/src/consumer/include/linux/atomic/atomic-arch-fallback.h:457 kbuild/src/consumer/include/linux/context_tracking.h:128 kbuild/src/consumer/kernel/rcu/tree.c:751) [ 81.221203][ C15] ? lock_acquire (kbuild/src/consumer/include/trace/events/lock.h:24 (discriminator 2) kbuild/src/consumer/kernel/locking/lockdep.c:5831 (discriminator 2)) [ 81.221208][ C15] ? process_one_work (kbuild/src/consumer/arch/x86/include/asm/jump_label.h:37 kbuild/src/consumer/include/trace/events/workqueue.h:110 kbuild/src/consumer/kernel/workqueue.c:3262) The kernel config and materials to reproduce are available at: https://download.01.org/0day-ci/archive/20260203/202602032100.d8e49b6f-lkp@intel.com -- 0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki ^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 3/3] lib/raid6: Delete the RAID6_PQ_BENCHMARK config 2026-01-28 10:49 [PATCH 0/3] lib/raid6: Optimize raid6_select_algo while ensuring sunliming 2026-01-28 10:49 ` [PATCH 1/3] lib/raid6: Divide the raid6 algorithm selection process into two parts sunliming 2026-01-28 10:49 ` [PATCH 2/3] lib/raid6: Optimizing the raid6_select_algo time through asynchronous processing sunliming @ 2026-01-28 10:49 ` sunliming 2 siblings, 0 replies; 6+ messages in thread From: sunliming @ 2026-01-28 10:49 UTC (permalink / raw) To: song, yukuai; +Cc: linux-raid, linux-kernel, sunliming From: sunliming <sunliming@kylinos.cn> Now RAID6 PQ functions is automatically choosed and the RAID6_PQ_BENCHMARK is not needed. Signed-off-by: sunliming <sunliming@kylinos.cn> --- lib/Kconfig | 8 -------- 1 file changed, 8 deletions(-) diff --git a/lib/Kconfig b/lib/Kconfig index 2923924bea78..841a0245a2c4 100644 --- a/lib/Kconfig +++ b/lib/Kconfig @@ -11,14 +11,6 @@ menu "Library routines" config RAID6_PQ tristate -config RAID6_PQ_BENCHMARK - bool "Automatically choose fastest RAID6 PQ functions" - depends on RAID6_PQ - default y - help - Benchmark all available RAID6 PQ functions on init and choose the - fastest one. - config LINEAR_RANGES tristate -- 2.25.1 ^ permalink raw reply related [flat|nested] 6+ messages in thread
end of thread, other threads:[~2026-02-03 13:54 UTC | newest] Thread overview: 6+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2026-01-28 10:49 [PATCH 0/3] lib/raid6: Optimize raid6_select_algo while ensuring sunliming 2026-01-28 10:49 ` [PATCH 1/3] lib/raid6: Divide the raid6 algorithm selection process into two parts sunliming 2026-01-29 3:26 ` Li Nan 2026-01-28 10:49 ` [PATCH 2/3] lib/raid6: Optimizing the raid6_select_algo time through asynchronous processing sunliming 2026-02-03 13:54 ` kernel test robot 2026-01-28 10:49 ` [PATCH 3/3] lib/raid6: Delete the RAID6_PQ_BENCHMARK config sunliming
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox