hugetlb: fix CONFIG_PADATA dependency for non-SMP system
Subsystems (3)
PATCH 1/1 hugetlb: fix CONFIG_PADATA dependency for non-SMP system
Randy Dunlap and kernel test robot reported a warning:
``` WARNING: unmet direct dependencies detected for PADATA Depends on [n]: SMP [=n] Selected by [y]: - HUGETLBFS [=y] && (X86 [=y] || SPARC64 || ARCH_SUPPORTS_HUGETLBFS [=n] || BROKEN [=n]) && (SYSFS [=y] || SYSCTL [=n]) ```
hugetlb parallelization depends on PADATA, and PADATA depends on SMP, so when the SMP config is disabled, the dependency of hugetlb on padata should be downgraded to single thread.
``` Hi Andrew, this fix patch is based on mm/mm-unstable. Thanks! ``` --- fs/Kconfig | 2 +- mm/hugetlb.c | 9 ++++++++- 2 files changed, 9 insertions(+), 2 deletions(-)
fs/Kconfig +1 -1
@@ -261,7 +261,7 @@ menuconfig HUGETLBFS depends on X86 || SPARC64 || ARCH_SUPPORTS_HUGETLBFS || BROKEN depends on (SYSFS || SYSCTL) select MEMFD_CREATE - select PADATA + select PADATA if SMP help hugetlbfs is a filesystem backing for HugeTLB pages, based on ramfs. For architectures that support it, say Y here and read
mm/hugetlb.c +8 -1
@@ -3457,6 +3457,7 @@ static void __init gather_bootmem_prealloc_node(unsigned long start, unsigned lostatic void __init gather_bootmem_prealloc (void ) { +#ifdef CONFIG_PADATA struct padata_mt_job job = { .thread_fn = gather_bootmem_prealloc_node, .fn_arg = NULL,
@@ -3469,6 +3470,9 @@ static void __init gather_bootmem_prealloc(void) };padata_do_multithreaded (&job); +#else +gather_bootmem_prealloc_node (0 ,0 ,NULL ); +#endif }static void __init hugetlb_hstate_alloc_pages_onenode (struct hstate *h,int nid)
@@ -3568,6 +3572,7 @@ static unsigned long __init hugetlb_gigantic_pages_alloc_boot(struct hstate *h)static unsigned long __init hugetlb_pages_alloc_boot (struct hstate *h) { +#ifdef CONFIG_PADATA struct padata_mt_job job = { .fn_arg = h, .align = 1,
@@ -3600,7 +3605,9 @@ static unsigned long __init hugetlb_pages_alloc_boot(struct hstate *h) job.max_threads =num_node_state (N_MEMORY ) *2 ; job.min_chunk = h->max_huge_pages /num_node_state (N_MEMORY ) /2 ;padata_do_multithreaded (&job); - +#else +hugetlb_pages_alloc_boot_node (0 , h->max_huge_pages, h); +#endif return h->nr_huge_pages; }
Signature · 1 line
2.20.1
Muchun Song
maintainerQuoted 33 lines · Gang Li
Randy Dunlap and kernel test robot reported a warning:
``` WARNING: unmet direct dependencies detected for PADATA Depends on [n]: SMP [=n] Selected by [y]: - HUGETLBFS [=y] && (X86 [=y] || SPARC64 || ARCH_SUPPORTS_HUGETLBFS [=n] || BROKEN [=n]) && (SYSFS [=y] || SYSCTL [=n]) ```hugetlb parallelization depends on PADATA, and PADATA depends on SMP, so when the SMP config is disabled, the dependency of hugetlb on padata should be downgraded to single thread.
Fixes f2f635264b98 ("hugetlb: have CONFIG_HUGETLBFS select CONFIG_PADATA")Reported-by Randy Dunlap <[email protected]>Reported-by kernel test robot <[email protected]>Signed-off-by Gang Li <[email protected]>``` Hi Andrew, this fix patch is based on mm/mm-unstable. Thanks! ``` --- fs/Kconfig | 2 +- mm/hugetlb.c | 9 ++++++++- 2 files changed, 9 insertions(+), 2 deletions(-)fs/Kconfig +0
-0
fs/Kconfig menuconfig HUGETLBFS · line 264
Quoted 5 lines
fs/Kconfig +1
-1@@ -261,7 +261,7 @@ menuconfig HUGETLBFS depends on X86 || SPARC64 || ARCH_SUPPORTS_HUGETLBFS || BROKEN depends on (SYSFS || SYSCTL) select MEMFD_CREATE - select PADATA + select PADATA if SMP
I don't think it is a clear way to fix this. If someone want to use PADATA in a non-SMP system, he should be carefully to handle the non-SMP case himself. I think the better way is to make PADATA handle the non-SMP case, I think it should be easy for it, which could just call ->thread_fn() many times instead of creating many threads in the non-SMP case.
Thanks.
Quoted 44 lines
fs/Kconfig +0
-0help hugetlbfs is a filesystem backing for HugeTLB pages, based on ramfs. For architectures that support it, say Y here and readmm/hugetlb.c +8
-1@@ -3457,6 +3457,7 @@ static void __init gather_bootmem_prealloc_node(unsigned long start, unsigned lostatic void __init gather_bootmem_prealloc (void ) { +#ifdef CONFIG_PADATA struct padata_mt_job job = { .thread_fn = gather_bootmem_prealloc_node, .fn_arg = NULL,@@ -3469,6 +3470,9 @@ static void __init gather_bootmem_prealloc(void) };padata_do_multithreaded (&job); +#else +gather_bootmem_prealloc_node (0 ,0 ,NULL ); +#endif }static void __init hugetlb_hstate_alloc_pages_onenode (struct hstate *h,int nid)@@ -3568,6 +3572,7 @@ static unsigned long __init hugetlb_gigantic_pages_alloc_boot(struct hstate *h)static unsigned long __init hugetlb_pages_alloc_boot (struct hstate *h) { +#ifdef CONFIG_PADATA struct padata_mt_job job = { .fn_arg = h, .align = 1,@@ -3600,7 +3605,9 @@ static unsigned long __init hugetlb_pages_alloc_boot(struct hstate *h) job.max_threads =num_node_state (N_MEMORY ) *2 ; job.min_chunk = h->max_huge_pages /num_node_state (N_MEMORY ) /2 ;padata_do_multithreaded (&job); - +#else +hugetlb_pages_alloc_boot_node (0 , h->max_huge_pages, h); +#endif return h->nr_huge_pages; }
Quoted 9 lines · Muchun Song
I don't think it is a clear way to fix this. If someone want to use PADATA in a non-SMP system, he should be carefully to handle the non-SMP case himself. I think the better way is to make PADATA handle the non-SMP case, I think it should be easy for it, which could just call ->thread_fn() many times instead of creating many threads in the non-SMP case.
Thanks.
Sounds good, I'll take a look at padata and send a new patch.
Quoted 8 lines · Gang Li
Quoted 7 lines · Muchun Song
I don't think it is a clear way to fix this. If someone want to use PADATA in a non-SMP system, he should be carefully to handle the non-SMP case himself. I think the better way is to make PADATA handle the non-SMP case, I think it should be easy for it, which could just call ->thread_fn() many times instead of creating many threads in the non-SMP case.
Quoted 4 lines
Quoted 2 lines
Thanks.
Sounds good, I'll take a look at padata and send a new patch.
1. delete the dependency on SMP
PADATA only depends on workqueue and completion. It works well with !SMP currently but has no performance benefits. What we can do is make PADATA handle the non-SMP case more elegantly.
PADATA has two parts: "Running Multithreaded Jobs" and "Running Serialized Jobs".
"Running Multithreaded Jobs", which hugetlb parallelization relies on can be easily deparallelize through this patch:
```
@@ -495,7 +495,7 @@ void __init padata_do_multithreaded(struct padata_mt_job *job)
nworks = max(job->size / max(job->min_chunk, job->align), 1ul);
nworks = min(nworks, job->max_threads);
- if (nworks == 1) {
+ if (nworks == 1 || !IS_ENABLED(CONFIG_SMP)) {
/* Single thread, no coordination needed, cut to the
chase. */
job->thread_fn(job->start, job->start + job->size,
job->fn_arg);
return;
```However, "Running Serialized Jobs" is more challenging due to its various workers queuing each other, making it more complex than "Running Multithreaded Jobs." I am currently in the process of deciphering the code.
To eliminate kconfig warnings, other methods could be considered:
2. Split hugetlb parallelization into a separate kconfig.
3. Wrap hugetlb parallelization with SMP or PADATA macros (already ruled out).
4. Split PADATA into PADATA_SERIALIZED and PADATA_MULTITHREADED (too heavy).
Anyway, this is only FYI. I will continue exploring how to deparallelize "Running Serialized Jobs."
Muchun Song
maintainerQuoted 42 lines · Gang Li
Quoted 11 lines · Gang Li
Quoted 9 lines · Muchun Song
I don't think it is a clear way to fix this. If someone want to use PADATA in a non-SMP system, he should be carefully to handle the non-SMP case himself. I think the better way is to make PADATA handle the non-SMP case, I think it should be easy for it, which could just call ->thread_fn() many times instead of creating many threads in the non-SMP case.
Thanks.
Sounds good, I'll take a look at padata and send a new patch.
1. delete the dependency on SMP
PADATA only depends on workqueue and completion. It works well with !SMP currently but has no performance benefits. What we can do is make PADATA handle the non-SMP case more elegantly.
PADATA has two parts: "Running Multithreaded Jobs" and "Running Serialized Jobs".
"Running Multithreaded Jobs", which hugetlb parallelization relies on can be easily deparallelize through this patch:
```
(quoted diff) +1
-1@@ -495,7 +495,7 @@ void __init padata_do_multithreaded(struct padata_mt_job *job) nworks = max(job->size / max(job->min_chunk, job->align), 1ul); nworks = min(nworks, job->max_threads); - if (nworks == 1) { + if (nworks == 1 || !IS_ENABLED(CONFIG_SMP)) { /* Single thread, no coordination needed, cut to the chase. */ job->thread_fn(job->start, job->start + job->size, job->fn_arg); return;```
Quoted 4 lines
However, "Running Serialized Jobs" is more challenging due to its various workers queuing each other, making it more complex than "Running Multithreaded Jobs." I am currently in the process of deciphering the code.
Actually, I did not get it. Why the above code cannot work? The above code already make it serialized in one call, right? What do I miss here?
Thanks.
Quoted 9 lines
To eliminate kconfig warnings, other methods could be considered:
2. Split hugetlb parallelization into a separate kconfig.
3. Wrap hugetlb parallelization with SMP or PADATA macros (already ruled out).
4. Split PADATA intoPADATA_SERIALIZEDandPADATA_MULTITHREADED(too heavy).Anyway, this is only FYI. I will continue exploring how to deparallelize "Running Serialized Jobs."
Quoted 5 lines · Muchun Song
Actually, I did not get it. Why the above code cannot work? The above code already make it serialized in one call, right? What do I miss here?
Thanks.
PADATA consists of two distinct functionality:
One part is padata_do_multithreaded, which disregards order and simply divides tasks into several groups for parallel execution. My patch use padata_do_multithreaded.
The other part is composed of a set of APIs that, while handling data in an out-of-order parallel manner, can eventually return the data with ordered sequence. Only crypto/pcrypt.c use them. I guess these APIs are designed specifically for crypto/pcrypt.c.
``` padata_alloc padata_alloc_shell padata_do_parallel padata_do_serial padata_free_shell padata_free ```