mm/mempolicy: some fix and semantics cleanup
Subsystems (2)
cover mm/mempolicy: some fix and semantics cleanup
Hi All,
We've posted v4 patchset introducing a new "perfer-many" memory policy
https://lore.kernel.org/lkml/[email protected]/ , for which Michal Hocko gave many comments while pointing out some problems, and we also found some semantics confusion about 'prefer'
and 'local' policy, as well as some duplicated code. This patchset tries to address them. Please help to review, thanks!
The patchset has been run with some sanity test like 'stress-ng' and 'ltp', and no problem found.
- Feng
Changelogs:
v1:
* use helper func instead of macro for patch 2/4 (David Rientjes)
* fix a possible null pointer case in patch 3/4
* update commit log for 1/4
RFC v2:
* add for oom check fix patch 1/4
* add the unification patch for mpol preprocess 2/4
Feng Tang (4):
mm/mempolicy: skip nodemask intersect check for 'interleave' when oom mm/mempolicy: unify the preprocessing for mbind and set_mempolicy mm/mempolicy: don't handle MPOL_LOCAL like a fake MPOL_PREFERRED
policy
mm/mempolicy: kill MPOL_F_LOCAL bit
include/uapi/linux/mempolicy.h | 1 + mm/mempolicy.c | 208 +++++++++++++++++++++-------------------- 2 files changed, 109 insertions(+), 100 deletions(-)
Signature · 1 line
2.7.4
PATCH 1/4 mm/mempolicy: skip nodemask intersect check for 'interleave' when oom
mempolicy_nodemask_intersects() is used in oom case to check if a task may have memory allocated on some memory nodes.
Currently, the nodes_intersects() is run for both 'bind' and 'interleave' policies. But they are different regarding memory allocation, the nodemask is a forced requirement for 'bind', while just a hint for 'interleave'. Like in alloc_pages_vma():
nmask = policy_nodemask(gfp, pol);
preferred_nid = policy_node(gfp, pol, node);
page = __alloc_pages(gfp, order, preferred_nid, nmask);in plicy_nodemask(), only 'bind' policy may return its desired nodemask, while others return NULL. And this 'NULL' enables the 'interleave' policy can get memory from other nodes than its nodemask.
So skip the nodemask intersect check for 'interleave' policy.
--- mm/mempolicy.c | 24 ++++-------------------- 1 file changed, 4 insertions(+), 20 deletions(-)
mm/mempolicy.c +4 -20
@@ -2098,7 +2098,7 @@ bool init_nodemask_of_mempolicy(nodemask_t *mask)* * If tsk's mempolicy is "default" [NULL], return 'true' to indicate default * policy. Otherwise, check for intersection between mask and the policy -* nodemask for 'bind' or 'interleave' policy. For 'preferred' or 'local' +* nodemask for 'bind' policy. For 'interleave', 'preferred' or 'local' * policy, always return true since it may allocate elsewhere on fallback. * * Takes task_lock(tsk) to prevent freeing of its mempolicy.
@@ -2111,29 +2111,13 @@ bool mempolicy_nodemask_intersects(struct task_struct *tsk,if (!mask)return ret; +task_lock (tsk); mempolicy = tsk->mempolicy; -if (!mempolicy) - goto out; - -switch (mempolicy->mode) { -case MPOL_PREFERRED : -/* -* MPOL_PREFERRED and MPOL_F_LOCAL are only preferred nodes to -* allocate from, they may fallback to other nodes when oom. -* Thus, it's possible for tsk to have allocated memory from -* nodes in mask. -*/ -break ; -case MPOL_BIND : -case MPOL_INTERLEAVE : +if (mempolicy && mempolicy->mode ==MPOL_BIND ) ret =nodes_intersects (mempolicy->v.nodes, *mask); -break ; -default : -BUG (); - } -out:task_unlock (tsk); +return ret; }
Signature · 1 line
2.7.4
Re: [PATCH v1 1/4] mm/mempolicy: skip nodemask intersect check for 'interleave' when oom
Quoted 12 lines · Feng Tang
mempolicy_nodemask_intersects()is used in oom case to check if a task may have memory allocated on some memory nodes.Currently, the
nodes_intersects()is run for both 'bind' and 'interleave' policies. But they are different regarding memory allocation, the nodemask is a forced requirement for 'bind', while just a hint for 'interleave'. Like inalloc_pages_vma():nmask = policy_nodemask(gfp, pol); preferred_nid = policy_node(gfp, pol, node); page = __alloc_pages(gfp, order, preferred_nid, nmask);
Quoted 5 lines
in
plicy_nodemask(), only 'bind' policy may return its desired nodemask, while others return NULL. And this 'NULL' enables the 'interleave' policy can get memory from other nodes than its nodemask.So skip the nodemask intersect check for 'interleave' policy.
The changelog is not really clear on the actual effect of the patch and the above reference to alloc_pages_vma looks misleading to me because that path is never called for interleaved policy.
This is very likely my fault because I was rather vague. The existing code in its current form is confusing but it _works_ properly. The problem is that it sounds like a general helper and in that regards the function is correct for the interleaved policy and your proposed preferred-many. But its only existing caller wants a different semantic.
Until now this was not a real problem even for OOM context because alloc_page_interleave is always used for the interleaving policy and that one doesn't use any node mask so the code is not really exercised. With your MPOL_PREFERRED this would no longer be the case.
Your patch makes the code more robust for the oom context but it can confuse other users who really want to do an intersect logic. So I think it would really be best to rename the function and make it oom specific. E.g. mempolicy_in_oom_domain(tsk, mask) this would make it clear that this is not a general purpose function.
The changelog should be clear that this is just a code cleanup rather than fix.
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 1/4] mm/mempolicy: skip nodemask intersect check for 'interleave' when oom
Quoted 17 lines · Michal Hocko
Quoted 16 lines · Feng Tang
mempolicy_nodemask_intersects()is used in oom case to check if a task may have memory allocated on some memory nodes.Currently, the
nodes_intersects()is run for both 'bind' and 'interleave' policies. But they are different regarding memory allocation, the nodemask is a forced requirement for 'bind', while just a hint for 'interleave'. Like inalloc_pages_vma():nmask = policy_nodemask(gfp, pol); preferred_nid = policy_node(gfp, pol, node); page = __alloc_pages(gfp, order, preferred_nid, nmask);in
plicy_nodemask(), only 'bind' policy may return its desired nodemask, while others return NULL. And this 'NULL' enables the 'interleave' policy can get memory from other nodes than its nodemask.
Quoted 5 lines
Quoted 1 line
So skip the nodemask intersect check for 'interleave' policy.
The changelog is not really clear on the actual effect of the patch and the above reference to
alloc_pages_vmalooks misleading to me because that path is never called for interleaved policy.
You are right. thanks for pointing it out.
Only the 'bind' policy calls policy_nodemask() and gets its preset nodemask, while for 'interleave', alloc_page_interleave() calls __alloc_pages() with NULL nodemask, so the conclusion is the same that 'bind' policy can only get memory from its preset nodemask, while 'interleave' can get memory from all nodes.
Quoted 10 lines
This is very likely my fault because I was rather vague. The existing code in its current form is confusing but it _works_ properly. The problem is that it sounds like a general helper and in that regards the function is correct for the interleaved policy and your proposed preferred-many. But its only existing caller wants a different semantic.
Until now this was not a real problem even for OOM context because
alloc_page_interleaveis always used for the interleaving policy and that one doesn't use any node mask so the code is not really exercised. With yourMPOL_PREFERREDthis would no longer be the case.
Given the 'interleave' task may have memory allocated from all nodes, shouldn't the mempolicy_nodemask_intersects() return true for 'interleave'? or I'm still missing something?
Quoted 5 lines
Your patch makes the code more robust for the oom context but it can confuse other users who really want to do an intersect logic. So I think it would really be best to rename the function and make it oom specific. E.g.
mempolicy_in_oom_domain(tsk, mask)this would make it clear that this is not a general purpose function.
Ok, will rename like this.
Thanks,
Feng
Quoted 6 lines
The changelog should be clear that this is just a code cleanup rather than fix.
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 1/4] mm/mempolicy: skip nodemask intersect check for 'interleave' when oom
Quoted 1 line · Feng Tang
On Thu, May 27, 2021 at 09:30:00AM +0200, Michal Hocko wrote:
[...]
Quoted 8 lines
Quoted 4 lines
Until now this was not a real problem even for OOM context because
alloc_page_interleaveis always used for the interleaving policy and that one doesn't use any node mask so the code is not really exercised. With yourMPOL_PREFERREDthis would no longer be the case.Given the 'interleave' task may have memory allocated from all nodes, shouldn't the
mempolicy_nodemask_intersects()return true for 'interleave'? or I'm still missing something?
Well, if you go with the renaming then it should be quite obvious that any policies which are not a hard binding should return true.
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 1/4] mm/mempolicy: skip nodemask intersect check for 'interleave' when oom
Quoted 8 lines · Michal Hocko
Quoted 1 line · Feng Tang
On Thu, May 27, 2021 at 09:30:00AM +0200, Michal Hocko wrote:
[...]
Quoted 5 lines
Quoted 4 lines
Until now this was not a real problem even for OOM context because
alloc_page_interleaveis always used for the interleaving policy and that one doesn't use any node mask so the code is not really exercised. With yourMPOL_PREFERREDthis would no longer be the case.
Quoted 6 lines
Quoted 3 lines
Given the 'interleave' task may have memory allocated from all nodes, shouldn't the
mempolicy_nodemask_intersects()return true for 'interleave'? or I'm still missing something?Well, if you go with the renaming then it should be quite obvious that any policies which are not a hard binding should return true.
Ok, will do the rename. thanks for clarifying!
- Feng
Quoted 3 lines
Signature · 2 lines
Michal Hocko SUSE Labs
PATCH 2/4 mm/mempolicy: unify the preprocessing for mbind and set_mempolicy
In reply to Feng TangCurrently the kernel_mbind() and kernel_set_mempolicy() do almost the same operation for parameter sanity check and preprocessing.
Add a helper function to unify the code to reduce the redundancy, and make it easier for changing the pre-processing code in future.
[thanks to David Rientjes for suggesting using helper function instead of macro]
--- mm/mempolicy.c | 43 ++++++++++++++++++++++++------------------- 1 file changed, 24 insertions(+), 19 deletions(-)
mm/mempolicy.c +24 -19
@@ -1460,6 +1460,20 @@ static int copy_nodes_to_user(unsigned long __user *mask, unsigned long maxnode,return copy_to_user (mask,nodes_addr (*nodes), copy) ? -EFAULT :0 ; } +static inline int mpol_pre_process (int *mode,const unsigned long __user *nmask,unsigned long maxnode,nodemask_t *nodes,unsigned short *flags) +{ +int ret; + + *flags = *mode &MPOL_MODE_FLAGS ; + *mode &= ~MPOL_MODE_FLAGS ; +if ((unsigned int )(*mode) >=MPOL_MAX ) +return -EINVAL ; +if ((*flags &MPOL_F_STATIC_NODES ) && (*flags &MPOL_F_RELATIVE_NODES )) +return -EINVAL ; + ret =get_nodes (nodes, nmask, maxnode); +return ret; +} +static long kernel_mbind (unsigned long start,unsigned long len,unsigned long mode,const unsigned long __user *nmask,unsigned long maxnode,unsigned int flags)
@@ -1467,19 +1481,14 @@ static long kernel_mbind(unsigned long start, unsigned long len,nodemask_t nodes;int err;unsigned short mode_flags; +int lmode = mode; - start =untagged_addr (start); - mode_flags = mode &MPOL_MODE_FLAGS ; - mode &= ~MPOL_MODE_FLAGS ; -if (mode >=MPOL_MAX ) -return -EINVAL ; -if ((mode_flags &MPOL_F_STATIC_NODES ) && - (mode_flags &MPOL_F_RELATIVE_NODES )) -return -EINVAL ; - err =get_nodes (&nodes, nmask, maxnode); + err =mpol_pre_process (&lmode, nmask, maxnode, &nodes, &mode_flags);if (err)return err; -return do_mbind (start, len, mode, mode_flags, &nodes, flags); + + start =untagged_addr (start); +return do_mbind (start, len, lmode, mode_flags, &nodes, flags); } SYSCALL_DEFINE6(mbind, unsigned long, start, unsigned long, len,
@@ -1495,18 +1504,14 @@ static long kernel_set_mempolicy(int mode, const unsigned long __user *nmask, {int err;nodemask_t nodes; -unsigned short flags; +unsigned short mode_flags; +int lmode = mode; - flags = mode &MPOL_MODE_FLAGS ; - mode &= ~MPOL_MODE_FLAGS ; -if ((unsigned int )mode >=MPOL_MAX ) -return -EINVAL ; -if ((flags &MPOL_F_STATIC_NODES ) && (flags &MPOL_F_RELATIVE_NODES )) -return -EINVAL ; - err =get_nodes (&nodes, nmask, maxnode); + err =mpol_pre_process (&lmode, nmask, maxnode, &nodes, &mode_flags);if (err)return err; -return do_set_mempolicy (mode, flags, &nodes); + +return do_set_mempolicy (lmode, mode_flags, &nodes); } SYSCALL_DEFINE3(set_mempolicy, int, mode, const unsigned long __user *, nmask,
Signature · 1 line
2.7.4
Re: [PATCH v1 2/4] mm/mempolicy: unify the preprocessing for mbind and set_mempolicy
Quoted 8 lines · Feng Tang
Currently the
kernel_mbind()andkernel_set_mempolicy()do almost the same operation for parameter sanity check and preprocessing.Add a helper function to unify the code to reduce the redundancy, and make it easier for changing the pre-processing code in future.
[thanks to David Rientjes for suggesting using helper function instead of macro]
I appreciate removing the code duplication but I am not really convinced this is an improvement. You are conflating two things. One is the mpol flags checking and node mask copying. While abstracting the first one makes sense to me the later is already a single line of code that makes your helper unnecessarily complex. So I would go with sanitize_mpol_flags and put a flags handling there and leave get_nodes alone.
Quoted 4 lines
Signed-off-by Feng Tang <[email protected]>--- mm/mempolicy.c | 43 ++++++++++++++++++++++++------------------- 1 file changed, 24 insertions(+), 19 deletions(-)
Funny how removing code duplication adds more code than it removes ;)
Quoted 77 lines
mm/mempolicy.c +24
-19@@ -1460,6 +1460,20 @@ static int copy_nodes_to_user(unsigned long __user *mask, unsigned long maxnode,return copy_to_user (mask,nodes_addr (*nodes), copy) ? -EFAULT :0 ; } +static inline int mpol_pre_process (int *mode,const unsigned long __user *nmask,unsigned long maxnode,nodemask_t *nodes,unsigned short *flags) +{ +int ret; + + *flags = *mode &MPOL_MODE_FLAGS ; + *mode &= ~MPOL_MODE_FLAGS ; +if ((unsigned int )(*mode) >=MPOL_MAX ) +return -EINVAL ; +if ((*flags &MPOL_F_STATIC_NODES ) && (*flags &MPOL_F_RELATIVE_NODES )) +return -EINVAL ; + ret =get_nodes (nodes, nmask, maxnode); +return ret; +} +static long kernel_mbind (unsigned long start,unsigned long len,unsigned long mode,const unsigned long __user *nmask,unsigned long maxnode,unsigned int flags)@@ -1467,19 +1481,14 @@ static long kernel_mbind(unsigned long start, unsigned long len,nodemask_t nodes;int err;unsigned short mode_flags; +int lmode = mode; - start =untagged_addr (start); - mode_flags = mode &MPOL_MODE_FLAGS ; - mode &= ~MPOL_MODE_FLAGS ; -if (mode >=MPOL_MAX ) -return -EINVAL ; -if ((mode_flags &MPOL_F_STATIC_NODES ) && - (mode_flags &MPOL_F_RELATIVE_NODES )) -return -EINVAL ; - err =get_nodes (&nodes, nmask, maxnode); + err =mpol_pre_process (&lmode, nmask, maxnode, &nodes, &mode_flags);if (err)return err; -return do_mbind (start, len, mode, mode_flags, &nodes, flags); + + start =untagged_addr (start); +return do_mbind (start, len, lmode, mode_flags, &nodes, flags); } SYSCALL_DEFINE6(mbind, unsigned long, start, unsigned long, len,@@ -1495,18 +1504,14 @@ static long kernel_set_mempolicy(int mode, const unsigned long __user *nmask, {int err;nodemask_t nodes; -unsigned short flags; +unsigned short mode_flags; +int lmode = mode; - flags = mode &MPOL_MODE_FLAGS ; - mode &= ~MPOL_MODE_FLAGS ; -if ((unsigned int )mode >=MPOL_MAX ) -return -EINVAL ; -if ((flags &MPOL_F_STATIC_NODES ) && (flags &MPOL_F_RELATIVE_NODES )) -return -EINVAL ; - err =get_nodes (&nodes, nmask, maxnode); + err =mpol_pre_process (&lmode, nmask, maxnode, &nodes, &mode_flags);if (err)return err; -return do_set_mempolicy (mode, flags, &nodes); + +return do_set_mempolicy (lmode, mode_flags, &nodes); } SYSCALL_DEFINE3(set_mempolicy, int, mode, const unsigned long __user *, nmask,Signature · 1 line
2.7.4
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 2/4] mm/mempolicy: unify the preprocessing for mbind and set_mempolicy
Quoted 17 lines · Michal Hocko
Quoted 8 lines · Feng Tang
Currently the
kernel_mbind()andkernel_set_mempolicy()do almost the same operation for parameter sanity check and preprocessing.Add a helper function to unify the code to reduce the redundancy, and make it easier for changing the pre-processing code in future.
[thanks to David Rientjes for suggesting using helper function instead of macro]
I appreciate removing the code duplication but I am not really convinced this is an improvement. You are conflating two things. One is the mpol flags checking and node mask copying. While abstracting the first one makes sense to me the later is already a single line of code that makes your helper unnecessarily complex. So I would go with
sanitize_mpol_flagsand put a flags handling there and leaveget_nodesalone.
Quoted 6 lines
Quoted 4 lines
Signed-off-by Feng Tang <[email protected]>--- mm/mempolicy.c | 43 ++++++++++++++++++++++++------------------- 1 file changed, 24 insertions(+), 19 deletions(-)Funny how removing code duplication adds more code than it removes ;)
Yes.
And in last verion which uses macro to unify the code:
https://lore.kernel.org/lkml/[email protected]/
it does save some lines :)
mm/mempolicy.c | 46 +++++++++++++++++++--------------------------- 1 file changed, 19 insertions(+), 27 deletions(-)
Thanks,
Feng
Quoted 81 lines
Quoted 77 lines
mm/mempolicy.c +24
-19@@ -1460,6 +1460,20 @@ static int copy_nodes_to_user(unsigned long __user *mask, unsigned long maxnode,return copy_to_user (mask,nodes_addr (*nodes), copy) ? -EFAULT :0 ; } +static inline int mpol_pre_process (int *mode,const unsigned long __user *nmask,unsigned long maxnode,nodemask_t *nodes,unsigned short *flags) +{ +int ret; + + *flags = *mode &MPOL_MODE_FLAGS ; + *mode &= ~MPOL_MODE_FLAGS ; +if ((unsigned int )(*mode) >=MPOL_MAX ) +return -EINVAL ; +if ((*flags &MPOL_F_STATIC_NODES ) && (*flags &MPOL_F_RELATIVE_NODES )) +return -EINVAL ; + ret =get_nodes (nodes, nmask, maxnode); +return ret; +} +static long kernel_mbind (unsigned long start,unsigned long len,unsigned long mode,const unsigned long __user *nmask,unsigned long maxnode,unsigned int flags)@@ -1467,19 +1481,14 @@ static long kernel_mbind(unsigned long start, unsigned long len,nodemask_t nodes;int err;unsigned short mode_flags; +int lmode = mode; - start =untagged_addr (start); - mode_flags = mode &MPOL_MODE_FLAGS ; - mode &= ~MPOL_MODE_FLAGS ; -if (mode >=MPOL_MAX ) -return -EINVAL ; -if ((mode_flags &MPOL_F_STATIC_NODES ) && - (mode_flags &MPOL_F_RELATIVE_NODES )) -return -EINVAL ; - err =get_nodes (&nodes, nmask, maxnode); + err =mpol_pre_process (&lmode, nmask, maxnode, &nodes, &mode_flags);if (err)return err; -return do_mbind (start, len, mode, mode_flags, &nodes, flags); + + start =untagged_addr (start); +return do_mbind (start, len, lmode, mode_flags, &nodes, flags); } SYSCALL_DEFINE6(mbind, unsigned long, start, unsigned long, len,@@ -1495,18 +1504,14 @@ static long kernel_set_mempolicy(int mode, const unsigned long __user *nmask, {int err;nodemask_t nodes; -unsigned short flags; +unsigned short mode_flags; +int lmode = mode; - flags = mode &MPOL_MODE_FLAGS ; - mode &= ~MPOL_MODE_FLAGS ; -if ((unsigned int )mode >=MPOL_MAX ) -return -EINVAL ; -if ((flags &MPOL_F_STATIC_NODES ) && (flags &MPOL_F_RELATIVE_NODES )) -return -EINVAL ; - err =get_nodes (&nodes, nmask, maxnode); + err =mpol_pre_process (&lmode, nmask, maxnode, &nodes, &mode_flags);if (err)return err; -return do_set_mempolicy (mode, flags, &nodes); + +return do_set_mempolicy (lmode, mode_flags, &nodes); } SYSCALL_DEFINE3(set_mempolicy, int, mode, const unsigned long __user *, nmask,Signature · 1 line
2.7.4Signature · 2 lines
Michal Hocko SUSE Labs
PATCH 3/4 mm/mempolicy: don't handle MPOL_LOCAL like a fake MPOL_PREFERRED policy
In reply to Feng TangMPOL_LOCAL policy has been setup as a real policy, but it is still handled like a faked POL_PREFERRED policy with one internal MPOL_F_LOCAL flag bit set, and there are many places having to judge the real 'prefer' or the 'local' policy, which are quite confusing.
In current code, there are four cases that MPOL_LOCAL are used:
* user specifies 'local' policy
* user specifies 'prefer' policy, but with empty nodemask
* system 'default' policy is used
* 'prefer' policy + valid 'preferred' node with MPOL_F_STATIC_NODES flag set, and when it is 'rebind' to a nodemask which doesn't contains the 'preferred' node, it will add the MPOL_F_LOCAL bit and performs as 'local' policy. In future if it is 'rebind' again with valid nodemask, the policy will be restored back to 'prefer'
So for the first three cases, we make 'local' a real policy instead of a fake 'prefer' one, this will reduce confusion for reading code.
And next optional patch will kill the 'MPOL_F_LOCAL' bit.
--- mm/mempolicy.c | 66 ++++++++++++++++++++++++++++++++++------------------------ 1 file changed, 39 insertions(+), 27 deletions(-)
mm/mempolicy.c +39 -27
@@ -121,8 +121,7 @@ enum zone_type policy_zone = 0;*/ static struct mempolicy default_policy = { .refcnt =ATOMIC_INIT (1 ),/* never free it */ - .mode =MPOL_PREFERRED , - .flags =MPOL_F_LOCAL , + .mode =MPOL_LOCAL , };static struct mempolicy preferred_node_policy[MAX_NUMNODES ];
@@ -200,12 +199,9 @@ static int mpol_new_interleave(struct mempolicy *pol, const nodemask_t *nodes)static int mpol_new_preferred (struct mempolicy *pol,const nodemask_t *nodes) { -if (!nodes) - pol->flags |=MPOL_F_LOCAL ;/* local allocation */ -else if (nodes_empty (*nodes)) -return -EINVAL ;/* no allowed nodes */ -else - pol->v.preferred_node =first_node (*nodes); +if (nodes_empty (*nodes)) +return -EINVAL ; + pol->v.preferred_node =first_node (*nodes);return 0 ; }
@@ -217,6 +213,11 @@ static int mpol_new_bind(struct mempolicy *pol, const nodemask_t *nodes)return 0 ; } +static int mpol_new_local (struct mempolicy *pol,const nodemask_t *nodes) +{ +return 0 ; +} +/* * mpol_set_nodemask is called after mpol_new() to set up the nodemask, if * any, for the new policy. mpol_new() has already validated the nodes
@@ -239,25 +240,19 @@ static int mpol_set_nodemask(struct mempolicy *pol, cpuset_current_mems_allowed, node_states[N_MEMORY]);VM_BUG_ON (!nodes); -if (pol->mode ==MPOL_PREFERRED &&nodes_empty (*nodes)) - nodes =NULL ;/* explicit local allocation */ -else { -if (pol->flags &MPOL_F_RELATIVE_NODES ) -mpol_relative_nodemask (&nsc->mask2, nodes, &nsc->mask1); -else -nodes_and (nsc->mask2, *nodes, nsc->mask1); -if (mpol_store_user_nodemask (pol)) - pol->w.user_nodemask = *nodes; -else - pol->w.cpuset_mems_allowed = - cpuset_current_mems_allowed; - } +if (pol->flags &MPOL_F_RELATIVE_NODES ) +mpol_relative_nodemask (&nsc->mask2, nodes, &nsc->mask1); +else +nodes_and (nsc->mask2, *nodes, nsc->mask1); -if (nodes) - ret = mpol_ops[pol->mode].create (pol, &nsc->mask2); +if (mpol_store_user_nodemask (pol)) + pol->w.user_nodemask = *nodes;else - ret = mpol_ops[pol->mode].create (pol,NULL ); + pol->w.cpuset_mems_allowed = + cpuset_current_mems_allowed; + + ret = mpol_ops[pol->mode].create (pol, &nsc->mask2);return ret; }
@@ -290,13 +285,14 @@ static struct mempolicy *mpol_new(unsigned short mode, unsigned short flags,if (((flags &MPOL_F_STATIC_NODES ) || (flags &MPOL_F_RELATIVE_NODES )))return ERR_PTR (-EINVAL ); + + mode =MPOL_LOCAL ; } }else if (mode ==MPOL_LOCAL ) {if (!nodes_empty (*nodes) || (flags &MPOL_F_STATIC_NODES ) || (flags &MPOL_F_RELATIVE_NODES ))return ERR_PTR (-EINVAL ); - mode =MPOL_PREFERRED ; }else if (nodes_empty (*nodes))return ERR_PTR (-EINVAL ); policy =kmem_cache_alloc (policy_cache,GFP_KERNEL );
@@ -427,6 +423,10 @@ static const struct mempolicy_operations mpol_ops[MPOL_MAX] = { .create = mpol_new_bind, .rebind = mpol_rebind_nodemask, }, + [MPOL_LOCAL] = { + .create = mpol_new_local, + .rebind = mpol_rebind_default, + }, }; static int migrate_page_add(struct page *page, struct list_head *pagelist,
@@ -1965,6 +1965,8 @@ unsigned int mempolicy_slab_node(void) &policy->v.nodes);return z->zone ?zone_to_nid (z->zone) : node; } +case MPOL_LOCAL : +return node;default :BUG ();
@@ -2089,6 +2091,11 @@ bool init_nodemask_of_mempolicy(nodemask_t *mask) *mask = mempolicy->v.nodes;break ; +case MPOL_LOCAL : + nid =numa_node_id (); +init_nodemask_of_node (mask, nid); +break ; +default :BUG (); }
@@ -2333,6 +2340,8 @@ bool __mpol_equal(struct mempolicy *a, struct mempolicy *b)if (a->flags &MPOL_F_LOCAL )return true;return a->v.preferred_node == b->v.preferred_node; +case MPOL_LOCAL : +return true;default :BUG ();return false;
@@ -2476,6 +2485,10 @@ int mpol_misplaced(struct page *page, struct vm_area_struct *vma, unsigned long polnid = pol->v.preferred_node;break ; +case MPOL_LOCAL : + polnid =numa_node_id (); +break ; +case MPOL_BIND :/* Optimize placement among multiple nodes via NUMA balancing */ if (pol->flags &MPOL_F_MORON ) {
@@ -2920,7 +2933,6 @@ int mpol_parse_str(char *str, struct mempolicy **mpol)*/ if (nodelist) goto out; - mode =MPOL_PREFERRED ;break ;case MPOL_DEFAULT :/*
@@ -2964,7 +2976,7 @@ int mpol_parse_str(char *str, struct mempolicy **mpol)else if (nodelist) new->v.preferred_node =first_node (nodes);else - new->flags |=MPOL_F_LOCAL ; + new->mode =MPOL_LOCAL ;/* * Save nodes for contextualization: this will be used to "clone"
Signature · 1 line
2.7.4
Re: [PATCH v1 3/4] mm/mempolicy: don't handle MPOL_LOCAL like a fake MPOL_PREFERRED policy
Quoted 16 lines · Feng Tang
MPOL_LOCALpolicy has been setup as a real policy, but it is still handled like a fakedPOL_PREFERREDpolicy with one internalMPOL_F_LOCALflag bit set, and there are many places having to judge the real 'prefer' or the 'local' policy, which are quite confusing.In current code, there are four cases that
MPOL_LOCALare used:
* user specifies 'local' policy
* user specifies 'prefer' policy, but with empty nodemask
* system 'default' policy is used
* 'prefer' policy + valid 'preferred' node withMPOL_F_STATIC_NODESflag set, and when it is 'rebind' to a nodemask which doesn't contains the 'preferred' node, it will add theMPOL_F_LOCALbit and performs as 'local' policy. In future if it is 'rebind' again with valid nodemask, the policy will be restored back to 'prefer'
Quoted 5 lines
So for the first three cases, we make 'local' a real policy instead of a fake 'prefer' one, this will reduce confusion for reading code.
And next optional patch will kill the '
MPOL_F_LOCAL' bit.
I do like this approach. An additional policy should be much easier to grasp than a special casing. This code is quite tricky so another pair of eyes would be definitely good for the review.
Quoted 1 line
Signed-off-by Feng Tang <[email protected]>
Just few nits.
mm/mempolicy.c unsigned int mempolicy_slab_node(void) · line 1969
Quoted 7 lines
static int migrate_page_add(struct page *page, struct
list_head*pagelist,mm/mempolicy.c +2
-0@@ -1965,6 +1965,8 @@ unsigned int mempolicy_slab_node(void) &policy->v.nodes);return z->zone ?zone_to_nid (z->zone) : node; } +case MPOL_LOCAL : +return node;
Any reason you haven't removed MPOL_F_LOCAL in this and following functions? It would make it much more easier to review this patch if there was no actual use of the flag in the code after this patch.
Quoted 35 lines
mm/mempolicy.c +11
-0default :BUG ();@@ -2089,6 +2091,11 @@ bool init_nodemask_of_mempolicy(nodemask_t *mask) *mask = mempolicy->v.nodes;break ; +case MPOL_LOCAL : + nid =numa_node_id (); +init_nodemask_of_node (mask, nid); +break ; +default :BUG (); }@@ -2333,6 +2340,8 @@ bool __mpol_equal(struct mempolicy *a, struct mempolicy *b)if (a->flags &MPOL_F_LOCAL )return true;return a->v.preferred_node == b->v.preferred_node; +case MPOL_LOCAL : +return true;default :BUG ();return false;@@ -2476,6 +2485,10 @@ int mpol_misplaced(struct page *page, struct vm_area_struct *vma, unsigned long polnid = pol->v.preferred_node;break ; +case MPOL_LOCAL : + polnid =numa_node_id (); +break ; +case MPOL_BIND :/* Optimize placement among multiple nodes via NUMA balancing */ if (pol->flags &MPOL_F_MORON ) {
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 3/4] mm/mempolicy: don't handle MPOL_LOCAL like a fake MPOL_PREFERRED policy
Hi Michal,
Many thanks for the reivews!
Quoted 23 lines · Michal Hocko
Quoted 16 lines · Feng Tang
MPOL_LOCALpolicy has been setup as a real policy, but it is still handled like a fakedPOL_PREFERREDpolicy with one internalMPOL_F_LOCALflag bit set, and there are many places having to judge the real 'prefer' or the 'local' policy, which are quite confusing.In current code, there are four cases that
MPOL_LOCALare used:
* user specifies 'local' policy
* user specifies 'prefer' policy, but with empty nodemask
* system 'default' policy is used
* 'prefer' policy + valid 'preferred' node withMPOL_F_STATIC_NODESflag set, and when it is 'rebind' to a nodemask which doesn't contains the 'preferred' node, it will add theMPOL_F_LOCALbit and performs as 'local' policy. In future if it is 'rebind' again with valid nodemask, the policy will be restored back to 'prefer'Quoted 5 lines
So for the first three cases, we make 'local' a real policy instead of a fake 'prefer' one, this will reduce confusion for reading code.
And next optional patch will kill the '
MPOL_F_LOCAL' bit.
Quoted 7 lines
I do like this approach. An additional policy should be much easier to grasp than a special casing. This code is quite tricky so another pair of eyes would be definitely good for the review.
Quoted 1 line
Signed-off-by Feng Tang <[email protected]>Acked-by Michal Hocko <[email protected]>
Thanks!
Quoted 13 lines
Just few nits.
mm/mempolicy.c unsigned int mempolicy_slab_node(void) · line 1969
Quoted 7 lines
static int migrate_page_add(struct page *page, struct
list_head*pagelist,mm/mempolicy.c +2
-0@@ -1965,6 +1965,8 @@ unsigned int mempolicy_slab_node(void) &policy->v.nodes);return z->zone ?zone_to_nid (z->zone) : node; } +case MPOL_LOCAL : +return node;Any reason you haven't removed
MPOL_F_LOCALin this and following functions? It would make it much more easier to review this patch if there was no actual use of the flag in the code after this patch.
As in the commit log, there are 4 cases using 'prefer' + MPOL_F_LOCAL to represent 'local' policy.
I'm confident in this patch which handle the case 1/2/3, while not sure if the solution (patch 4/4) for case 4 is the right method. So I separte them into 3/4 and 4/4
Thanks,
Feng
Quoted 38 lines
Quoted 35 lines
mm/mempolicy.c +11
-0default :BUG ();@@ -2089,6 +2091,11 @@ bool init_nodemask_of_mempolicy(nodemask_t *mask) *mask = mempolicy->v.nodes;break ; +case MPOL_LOCAL : + nid =numa_node_id (); +init_nodemask_of_node (mask, nid); +break ; +default :BUG (); }@@ -2333,6 +2340,8 @@ bool __mpol_equal(struct mempolicy *a, struct mempolicy *b)if (a->flags &MPOL_F_LOCAL )return true;return a->v.preferred_node == b->v.preferred_node; +case MPOL_LOCAL : +return true;default :BUG ();return false;@@ -2476,6 +2485,10 @@ int mpol_misplaced(struct page *page, struct vm_area_struct *vma, unsigned long polnid = pol->v.preferred_node;break ; +case MPOL_LOCAL : + polnid =numa_node_id (); +break ; +case MPOL_BIND :/* Optimize placement among multiple nodes via NUMA balancing */ if (pol->flags &MPOL_F_MORON ) {Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 3/4] mm/mempolicy: don't handle MPOL_LOCAL like a fake MPOL_PREFERRED policy
Quoted 52 lines · Feng Tang
Hi Michal,
Many thanks for the reivews!
Quoted 23 lines · Michal Hocko
Quoted 16 lines · Feng Tang
MPOL_LOCALpolicy has been setup as a real policy, but it is still handled like a fakedPOL_PREFERREDpolicy with one internalMPOL_F_LOCALflag bit set, and there are many places having to judge the real 'prefer' or the 'local' policy, which are quite confusing.In current code, there are four cases that
MPOL_LOCALare used:
* user specifies 'local' policy
* user specifies 'prefer' policy, but with empty nodemask
* system 'default' policy is used
* 'prefer' policy + valid 'preferred' node withMPOL_F_STATIC_NODESflag set, and when it is 'rebind' to a nodemask which doesn't contains the 'preferred' node, it will add theMPOL_F_LOCALbit and performs as 'local' policy. In future if it is 'rebind' again with valid nodemask, the policy will be restored back to 'prefer'Quoted 5 lines
So for the first three cases, we make 'local' a real policy instead of a fake 'prefer' one, this will reduce confusion for reading code.
And next optional patch will kill the '
MPOL_F_LOCAL' bit.Quoted 7 lines
I do like this approach. An additional policy should be much easier to grasp than a special casing. This code is quite tricky so another pair of eyes would be definitely good for the review.
Quoted 1 line
Signed-off-by Feng Tang <[email protected]>Acked-by Michal Hocko <[email protected]>Thanks!
Quoted 13 lines
Just few nits.
mm/mempolicy.c unsigned int mempolicy_slab_node(void) · line 1969
Quoted 7 lines
static int migrate_page_add(struct page *page, struct
list_head*pagelist,mm/mempolicy.c +2
-0@@ -1965,6 +1965,8 @@ unsigned int mempolicy_slab_node(void) &policy->v.nodes);return z->zone ?zone_to_nid (z->zone) : node; } +case MPOL_LOCAL : +return node;Any reason you haven't removed
MPOL_F_LOCALin this and following functions? It would make it much more easier to review this patch if there was no actual use of the flag in the code after this patch.
Quoted 6 lines
As in the commit log, there are 4 cases using 'prefer' +
MPOL_F_LOCALto represent 'local' policy.I'm confident in this patch which handle the case 1/2/3, while not sure if the solution (patch 4/4) for case 4 is the right method. So I separte them into 3/4 and 4/4
Please don't and handle the above and those below in a single patch.
Quoted 42 lines
Thanks,
FengQuoted 38 lines
Quoted 35 lines
mm/mempolicy.c +11
-0default :BUG ();@@ -2089,6 +2091,11 @@ bool init_nodemask_of_mempolicy(nodemask_t *mask) *mask = mempolicy->v.nodes;break ; +case MPOL_LOCAL : + nid =numa_node_id (); +init_nodemask_of_node (mask, nid); +break ; +default :BUG (); }@@ -2333,6 +2340,8 @@ bool __mpol_equal(struct mempolicy *a, struct mempolicy *b)if (a->flags &MPOL_F_LOCAL )return true;return a->v.preferred_node == b->v.preferred_node; +case MPOL_LOCAL : +return true;default :BUG ();return false;@@ -2476,6 +2485,10 @@ int mpol_misplaced(struct page *page, struct vm_area_struct *vma, unsigned long polnid = pol->v.preferred_node;break ; +case MPOL_LOCAL : + polnid =numa_node_id (); +break ; +case MPOL_BIND :/* Optimize placement among multiple nodes via NUMA balancing */ if (pol->flags &MPOL_F_MORON ) {Signature · 2 lines
Michal Hocko SUSE Labs
Signature · 2 lines
Michal Hocko SUSE Labs
PATCH 4/4 mm/mempolicy: kill MPOL_F_LOCAL bit
In reply to Feng TangNow the only remaining case of a real 'local' policy faked by 'prefer' policy plus MPOL_F_LOCAL bit is:
A valid 'prefer' policy with a valid 'preferred' node is 'rebind' to a nodemask which doesn't contains the 'preferred' node, then it will handle allocation with 'local' policy.
Add a new 'MPOL_F_LOCAL_TEMP' bit for this case, and kill the MPOL_F_LOCAL bit, which could simplify the code much.
--- include/uapi/linux/mempolicy.h | 1 + mm/mempolicy.c | 77 +++++++++++++++++++++++------------------- 2 files changed, 43 insertions(+), 35 deletions(-)
include/uapi/linux/mempolicy.h +1 -0
@@ -63,6 +63,7 @@ enum {#define MPOL_F_LOCAL (1 << 1)/* preferred local allocation */ #define MPOL_F_MOF (1 << 3)/* this policy wants migrate on fault */ #define MPOL_F_MORON (1 << 4)/* Migrate On protnone Reference On Node */ +#define MPOL_F_LOCAL_TEMP (1 << 5)/* a policy temporarily changed from 'prefer' to 'local' */ /* * These bit locations are exposed in the vm.zone_reclaim_mode sysctl
mm/mempolicy.c +42 -35
171 lines not on this page · raw message
Signature · 1 line
2.7.4
Re: [PATCH v1 4/4] mm/mempolicy: kill MPOL_F_LOCAL bit
Quoted 9 lines · Feng Tang
Now the only remaining case of a real 'local' policy faked by 'prefer' policy plus
MPOL_F_LOCALbit is:A valid 'prefer' policy with a valid 'preferred' node is 'rebind' to a nodemask which doesn't contains the 'preferred' node, then it will handle allocation with 'local' policy.
Add a new '
MPOL_F_LOCAL_TEMP' bit for this case, and kill theMPOL_F_LOCALbit, which could simplify the code much.
As I've pointed out in the reply to the previous patch. It would have been much better if most of the MPOL_F_LOCAL usage was gone by this patch.
I also dislike a new MPOL_F_LOCAL_TEMP. This smells like sneaking the hack back in after you have painstakingly removed it. So this looks like a step backwards to me. I also do not understand why do we need the rebind callback for local policy at all. There is no node mask for local so what is going on here?
[...]
Quoted 6 lines
mm/mempolicy.c +6
-0+static void mpol_rebind_local (struct mempolicy *pol, +const nodemask_t *nodes) +{ +if (unlikely (pol->flags &MPOL_F_STATIC_NODES )) { +int node =first_node (pol->w.user_nodemask); +
mm/mempolicy.c static void mpol_rebind_nodemask(struct mempolicy *pol, const nodemask_t *nodes) · line 355
Quoted 10 lines
mm/mempolicy.c +10
-0+BUG_ON (!(pol->flags &MPOL_F_LOCAL_TEMP )); + +if (node_isset (node, *nodes)) { + pol->v.preferred_node = node; + pol->mode =MPOL_PREFERRED ; + pol->flags &= ~MPOL_F_LOCAL_TEMP ; + } + } +} +
I have to confess I've got lost here. Could you explain why do you need all this handling for a local policy?
Quoted 44 lines
static void mpol_rebind_preferred(struct mempolicy *pol,
mm/mempolicy.c +12
-6const nodemask_t *nodes) {@@ -347,13 +363,19 @@ static void mpol_rebind_preferred(struct mempolicy *pol,if (node_isset (node, *nodes)) { pol->v.preferred_node = node; - pol->flags &= ~MPOL_F_LOCAL ; - }else - pol->flags |=MPOL_F_LOCAL ; + }else { +/* +* If there is no valid node, change the mode to +* MPOL_LOCAL, which will be restored back when +* next rebind() sees a valid node. +*/ + pol->mode =MPOL_LOCAL ; + pol->flags |=MPOL_F_LOCAL_TEMP ; + } }else if (pol->flags &MPOL_F_RELATIVE_NODES ) {mpol_relative_nodemask (&tmp, &pol->w.user_nodemask, nodes); pol->v.preferred_node =first_node (tmp); - }else if (!(pol->flags &MPOL_F_LOCAL )) { + }else { pol->v.preferred_node =node_remap (pol->v.preferred_node, pol->w.cpuset_mems_allowed, *nodes);@@ -372,7 +394,7 @@ static void mpol_rebind_policy(struct mempolicy *pol, const nodemask_t *newmask) {if (!pol)return ; -if (!mpol_store_user_nodemask (pol) && !(pol->flags &MPOL_F_LOCAL ) && +if (!mpol_store_user_nodemask (pol) &&nodes_equal (pol->w.cpuset_mems_allowed, *newmask))return ;@@ -425,7 +447,7 @@ static const struct mempolicy_operations mpol_ops[MPOL_MAX] = { }, [MPOL_LOCAL ] = { .create = mpol_new_local, - .rebind = mpol_rebind_default, + .rebind = mpol_rebind_local, }, };
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 4/4] mm/mempolicy: kill MPOL_F_LOCAL bit
Quoted 15 lines · Michal Hocko
Quoted 9 lines · Feng Tang
Now the only remaining case of a real 'local' policy faked by 'prefer' policy plus
MPOL_F_LOCALbit is:A valid 'prefer' policy with a valid 'preferred' node is 'rebind' to a nodemask which doesn't contains the 'preferred' node, then it will handle allocation with 'local' policy.
Add a new '
MPOL_F_LOCAL_TEMP' bit for this case, and kill theMPOL_F_LOCALbit, which could simplify the code much.As I've pointed out in the reply to the previous patch. It would have been much better if most of the
MPOL_F_LOCALusage was gone by this patch.
Quoted 5 lines
I also dislike a new
MPOL_F_LOCAL_TEMP. This smells like sneaking the hack back in after you have painstakingly removed it. So this looks like a step backwards to me. I also do not understand why do we need the rebind callback for local policy at all. There is no node mask for local so what is going on here?
This is the special case 4 for 'perfer' policy with MPOL_F_STATIC_NODES flag set, say it prefer node 1, when it is later 'refind' to a new nodemask node 2-3, according to current code it will be add the MPOL_F_LOCAL bit and performs 'local' policy acctually. And in future it is 'rebind' again with a nodemask 1-2, it will be restored back to 'prefer' policy with preferred node 1.
This patch tries to address this special case. I have struggled but couldn't think of a good way. Any suggestions? thanks!
- Feng
Quoted 68 lines
[...]
Quoted 6 lines
mm/mempolicy.c +6
-0+static void mpol_rebind_local (struct mempolicy *pol, +const nodemask_t *nodes) +{ +if (unlikely (pol->flags &MPOL_F_STATIC_NODES )) { +int node =first_node (pol->w.user_nodemask); +mm/mempolicy.c static void mpol_rebind_nodemask(struct mempolicy *pol, const nodemask_t *nodes) · line 355
Quoted 10 lines
mm/mempolicy.c +10
-0+BUG_ON (!(pol->flags &MPOL_F_LOCAL_TEMP )); + +if (node_isset (node, *nodes)) { + pol->v.preferred_node = node; + pol->mode =MPOL_PREFERRED ; + pol->flags &= ~MPOL_F_LOCAL_TEMP ; + } + } +} +I have to confess I've got lost here. Could you explain why do you need all this handling for a local policy?
Quoted 44 lines
static void mpol_rebind_preferred(struct mempolicy *pol,
mm/mempolicy.c +12
-6const nodemask_t *nodes) {@@ -347,13 +363,19 @@ static void mpol_rebind_preferred(struct mempolicy *pol,if (node_isset (node, *nodes)) { pol->v.preferred_node = node; - pol->flags &= ~MPOL_F_LOCAL ; - }else - pol->flags |=MPOL_F_LOCAL ; + }else { +/* +* If there is no valid node, change the mode to +* MPOL_LOCAL, which will be restored back when +* next rebind() sees a valid node. +*/ + pol->mode =MPOL_LOCAL ; + pol->flags |=MPOL_F_LOCAL_TEMP ; + } }else if (pol->flags &MPOL_F_RELATIVE_NODES ) {mpol_relative_nodemask (&tmp, &pol->w.user_nodemask, nodes); pol->v.preferred_node =first_node (tmp); - }else if (!(pol->flags &MPOL_F_LOCAL )) { + }else { pol->v.preferred_node =node_remap (pol->v.preferred_node, pol->w.cpuset_mems_allowed, *nodes);@@ -372,7 +394,7 @@ static void mpol_rebind_policy(struct mempolicy *pol, const nodemask_t *newmask) {if (!pol)return ; -if (!mpol_store_user_nodemask (pol) && !(pol->flags &MPOL_F_LOCAL ) && +if (!mpol_store_user_nodemask (pol) &&nodes_equal (pol->w.cpuset_mems_allowed, *newmask))return ;@@ -425,7 +447,7 @@ static const struct mempolicy_operations mpol_ops[MPOL_MAX] = { }, [MPOL_LOCAL ] = { .create = mpol_new_local, - .rebind = mpol_rebind_default, + .rebind = mpol_rebind_local, }, };Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 4/4] mm/mempolicy: kill MPOL_F_LOCAL bit
Quoted 22 lines · Feng Tang
Quoted 15 lines · Michal Hocko
Quoted 9 lines · Feng Tang
Now the only remaining case of a real 'local' policy faked by 'prefer' policy plus
MPOL_F_LOCALbit is:A valid 'prefer' policy with a valid 'preferred' node is 'rebind' to a nodemask which doesn't contains the 'preferred' node, then it will handle allocation with 'local' policy.
Add a new '
MPOL_F_LOCAL_TEMP' bit for this case, and kill theMPOL_F_LOCALbit, which could simplify the code much.As I've pointed out in the reply to the previous patch. It would have been much better if most of the
MPOL_F_LOCALusage was gone by this patch.Quoted 5 lines
I also dislike a new
MPOL_F_LOCAL_TEMP. This smells like sneaking the hack back in after you have painstakingly removed it. So this looks like a step backwards to me. I also do not understand why do we need the rebind callback for local policy at all. There is no node mask for local so what is going on here?
Quoted 6 lines
This is the special case 4 for 'perfer' policy with
MPOL_F_STATIC_NODESflag set, say it prefer node 1, when it is later 'refind' to a new nodemask node 2-3, according to current code it will be add theMPOL_F_LOCALbit and performs 'local' policy acctually. And in future it is 'rebind' again with a nodemask 1-2, it will be restored back to 'prefer' policy with preferred node 1.
Honestly I still do not follow the actual problem. A preferred node is a _hint_. If you rebind the task to a different cpuset then why should we actually care? The allocator will fallback to the closest node according to the distance metric. Maybe the original code was trying to handle that in some way but I really do fail to understand that code and I strongly suspect it is more likely to overengineered rather than backed by a real usecase. I might be wrong here but then this is an excellent opportunity to clarify all those subtleties.
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 4/4] mm/mempolicy: kill MPOL_F_LOCAL bit
Quoted 23 lines · Michal Hocko
Quoted 22 lines · Feng Tang
Quoted 20 lines · Michal Hocko
Quoted 9 lines · Feng Tang
Now the only remaining case of a real 'local' policy faked by 'prefer' policy plus
MPOL_F_LOCALbit is:A valid 'prefer' policy with a valid 'preferred' node is 'rebind' to a nodemask which doesn't contains the 'preferred' node, then it will handle allocation with 'local' policy.
Add a new '
MPOL_F_LOCAL_TEMP' bit for this case, and kill theMPOL_F_LOCALbit, which could simplify the code much.As I've pointed out in the reply to the previous patch. It would have been much better if most of the
MPOL_F_LOCALusage was gone by this patch.I also dislike a new
MPOL_F_LOCAL_TEMP. This smells like sneaking the hack back in after you have painstakingly removed it. So this looks like a step backwards to me. I also do not understand why do we need the rebind callback for local policy at all. There is no node mask for local so what is going on here?
Quoted 8 lines
Quoted 6 lines
This is the special case 4 for 'perfer' policy with
MPOL_F_STATIC_NODESflag set, say it prefer node 1, when it is later 'refind' to a new nodemask node 2-3, according to current code it will be add theMPOL_F_LOCALbit and performs 'local' policy acctually. And in future it is 'rebind' again with a nodemask 1-2, it will be restored back to 'prefer' policy with preferred node 1.Honestly I still do not follow the actual problem.
I was confused too, and don't know the original thought behind it. This case 4 was just imagined by reading the code.
Quoted 8 lines
A preferred node is a
_hint_. If you rebind the task to a different cpuset then why should we actually care? The allocator will fallback to the closest node according to the distance metric. Maybe the original code was trying to handle that in some way but I really do fail to understand that code and I strongly suspect it is more likely to overengineered rather than backed by a real usecase. I might be wrong here but then this is an excellent opportunity to clarify all those subtleties.
From the code, the original special handling may be needed in 3 cases:
get_policy_nodemask()
policy_node()
mempolicy_slab_node()
to not return the preset prefer_nid.
Thanks,
Feng
Quoted 3 lines
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 4/4] mm/mempolicy: kill MPOL_F_LOCAL bit
Quoted 45 lines · Feng Tang
Quoted 23 lines · Michal Hocko
Quoted 22 lines · Feng Tang
Quoted 20 lines · Michal Hocko
Quoted 9 lines · Feng Tang
Now the only remaining case of a real 'local' policy faked by 'prefer' policy plus
MPOL_F_LOCALbit is:A valid 'prefer' policy with a valid 'preferred' node is 'rebind' to a nodemask which doesn't contains the 'preferred' node, then it will handle allocation with 'local' policy.
Add a new '
MPOL_F_LOCAL_TEMP' bit for this case, and kill theMPOL_F_LOCALbit, which could simplify the code much.As I've pointed out in the reply to the previous patch. It would have been much better if most of the
MPOL_F_LOCALusage was gone by this patch.I also dislike a new
MPOL_F_LOCAL_TEMP. This smells like sneaking the hack back in after you have painstakingly removed it. So this looks like a step backwards to me. I also do not understand why do we need the rebind callback for local policy at all. There is no node mask for local so what is going on here?Quoted 8 lines
Quoted 6 lines
This is the special case 4 for 'perfer' policy with
MPOL_F_STATIC_NODESflag set, say it prefer node 1, when it is later 'refind' to a new nodemask node 2-3, according to current code it will be add theMPOL_F_LOCALbit and performs 'local' policy acctually. And in future it is 'rebind' again with a nodemask 1-2, it will be restored back to 'prefer' policy with preferred node 1.Honestly I still do not follow the actual problem.
I was confused too, and don't know the original thought behind it. This case 4 was just imagined by reading the code.
Quoted 8 lines
A preferred node is a
_hint_. If you rebind the task to a different cpuset then why should we actually care? The allocator will fallback to the closest node according to the distance metric. Maybe the original code was trying to handle that in some way but I really do fail to understand that code and I strongly suspect it is more likely to overengineered rather than backed by a real usecase. I might be wrong here but then this is an excellent opportunity to clarify all those subtleties.
Quoted 5 lines
From the code, the original special handling may be needed in 3 cases:
get_policy_nodemask()
policy_node()
mempolicy_slab_node()
to not return the presetprefer_nid.
I am sorry but I do not follow. What is actually wrong if the preferred node is outside of the cpuset nodemask?
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 4/4] mm/mempolicy: kill MPOL_F_LOCAL bit
Quoted 46 lines · Michal Hocko
Quoted 45 lines · Feng Tang
Quoted 23 lines · Michal Hocko
Quoted 22 lines · Feng Tang
Quoted 20 lines · Michal Hocko
Quoted 9 lines · Feng Tang
Now the only remaining case of a real 'local' policy faked by 'prefer' policy plus
MPOL_F_LOCALbit is:A valid 'prefer' policy with a valid 'preferred' node is 'rebind' to a nodemask which doesn't contains the 'preferred' node, then it will handle allocation with 'local' policy.
Add a new '
MPOL_F_LOCAL_TEMP' bit for this case, and kill theMPOL_F_LOCALbit, which could simplify the code much.As I've pointed out in the reply to the previous patch. It would have been much better if most of the
MPOL_F_LOCALusage was gone by this patch.I also dislike a new
MPOL_F_LOCAL_TEMP. This smells like sneaking the hack back in after you have painstakingly removed it. So this looks like a step backwards to me. I also do not understand why do we need the rebind callback for local policy at all. There is no node mask for local so what is going on here?Quoted 8 lines
Quoted 6 lines
This is the special case 4 for 'perfer' policy with
MPOL_F_STATIC_NODESflag set, say it prefer node 1, when it is later 'refind' to a new nodemask node 2-3, according to current code it will be add theMPOL_F_LOCALbit and performs 'local' policy acctually. And in future it is 'rebind' again with a nodemask 1-2, it will be restored back to 'prefer' policy with preferred node 1.Honestly I still do not follow the actual problem.
I was confused too, and don't know the original thought behind it. This case 4 was just imagined by reading the code.
Quoted 8 lines
A preferred node is a
_hint_. If you rebind the task to a different cpuset then why should we actually care? The allocator will fallback to the closest node according to the distance metric. Maybe the original code was trying to handle that in some way but I really do fail to understand that code and I strongly suspect it is more likely to overengineered rather than backed by a real usecase. I might be wrong here but then this is an excellent opportunity to clarify all those subtleties.
Quoted 8 lines
Quoted 5 lines
From the code, the original special handling may be needed in 3 cases:
get_policy_nodemask()
policy_node()
mempolicy_slab_node()
to not return the presetprefer_nid.I am sorry but I do not follow. What is actually wrong if the preferred node is outside of the cpuset nodemask?
Sorry, I didn't make it clear. With current code logic, it will perform as 'local' policy, but its mode is kept as 'prefer', so the code still has these tricky bit checking when these APIs are called for this policy. I agree with you that these ping-pong rebind() may be over engineering, so for this case can we just change the policy from 'prefer' to 'local', and drop the tricky bit manipulation, as the 'prefer' is just a hint, if these rebind misses the target node, there is no need to stick with the 'prefer' policy?
Thanks,
Feng
Re: [PATCH v1 4/4] mm/mempolicy: kill MPOL_F_LOCAL bit
Quoted 56 lines · Feng Tang
Quoted 46 lines · Michal Hocko
Quoted 45 lines · Feng Tang
Quoted 23 lines · Michal Hocko
Quoted 22 lines · Feng Tang
Quoted 20 lines · Michal Hocko
Quoted 9 lines · Feng Tang
Now the only remaining case of a real 'local' policy faked by 'prefer' policy plus
MPOL_F_LOCALbit is:A valid 'prefer' policy with a valid 'preferred' node is 'rebind' to a nodemask which doesn't contains the 'preferred' node, then it will handle allocation with 'local' policy.
Add a new '
MPOL_F_LOCAL_TEMP' bit for this case, and kill theMPOL_F_LOCALbit, which could simplify the code much.As I've pointed out in the reply to the previous patch. It would have been much better if most of the
MPOL_F_LOCALusage was gone by this patch.I also dislike a new
MPOL_F_LOCAL_TEMP. This smells like sneaking the hack back in after you have painstakingly removed it. So this looks like a step backwards to me. I also do not understand why do we need the rebind callback for local policy at all. There is no node mask for local so what is going on here?Quoted 8 lines
Quoted 6 lines
This is the special case 4 for 'perfer' policy with
MPOL_F_STATIC_NODESflag set, say it prefer node 1, when it is later 'refind' to a new nodemask node 2-3, according to current code it will be add theMPOL_F_LOCALbit and performs 'local' policy acctually. And in future it is 'rebind' again with a nodemask 1-2, it will be restored back to 'prefer' policy with preferred node 1.Honestly I still do not follow the actual problem.
I was confused too, and don't know the original thought behind it. This case 4 was just imagined by reading the code.
Quoted 8 lines
A preferred node is a
_hint_. If you rebind the task to a different cpuset then why should we actually care? The allocator will fallback to the closest node according to the distance metric. Maybe the original code was trying to handle that in some way but I really do fail to understand that code and I strongly suspect it is more likely to overengineered rather than backed by a real usecase. I might be wrong here but then this is an excellent opportunity to clarify all those subtleties.Quoted 8 lines
Quoted 5 lines
From the code, the original special handling may be needed in 3 cases:
get_policy_nodemask()
policy_node()
mempolicy_slab_node()
to not return the presetprefer_nid.I am sorry but I do not follow. What is actually wrong if the preferred node is outside of the cpuset nodemask?
Quoted 8 lines
Sorry, I didn't make it clear. With current code logic, it will perform as 'local' policy, but its mode is kept as 'prefer', so the code still has these tricky bit checking when these APIs are called for this policy. I agree with you that these ping-pong
rebind()may be over engineering, so for this case can we just change the policy from 'prefer' to 'local', and drop the tricky bit manipulation, as the 'prefer' is just a hint, if these rebind misses the target node, there is no need to stick with the 'prefer' policy?
Again. I really do not understand why we should rebind or mark as local anything here. Is this a documented/expected behavior? What if somebody just changes the cpuset to include the preferred node again. Is it expected to have local preference now?
I can see you have posted a newer version which I haven't seen yet but this is really better to get resolved before building up more on top. And let me be explicit. I do believe that rebinding preferred policy is just bogus and it should be dropped altogether on the ground that a preference is a mere hint from userspace where to start the allocation. Unless I am missing something cpusets will be always authoritative for the final placement. The preferred node just acts as a starting point and it should be really preserved when cpusets changes. Otherwise we have a very subtle behavior corner cases.
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 4/4] mm/mempolicy: kill MPOL_F_LOCAL bit
Quoted 66 lines · Michal Hocko
Quoted 56 lines · Feng Tang
Quoted 46 lines · Michal Hocko
Quoted 45 lines · Feng Tang
Quoted 23 lines · Michal Hocko
Quoted 22 lines · Feng Tang
Quoted 20 lines · Michal Hocko
Quoted 9 lines · Feng Tang
Now the only remaining case of a real 'local' policy faked by 'prefer' policy plus
MPOL_F_LOCALbit is:A valid 'prefer' policy with a valid 'preferred' node is 'rebind' to a nodemask which doesn't contains the 'preferred' node, then it will handle allocation with 'local' policy.
Add a new '
MPOL_F_LOCAL_TEMP' bit for this case, and kill theMPOL_F_LOCALbit, which could simplify the code much.As I've pointed out in the reply to the previous patch. It would have been much better if most of the
MPOL_F_LOCALusage was gone by this patch.I also dislike a new
MPOL_F_LOCAL_TEMP. This smells like sneaking the hack back in after you have painstakingly removed it. So this looks like a step backwards to me. I also do not understand why do we need the rebind callback for local policy at all. There is no node mask for local so what is going on here?Quoted 8 lines
Quoted 6 lines
This is the special case 4 for 'perfer' policy with
MPOL_F_STATIC_NODESflag set, say it prefer node 1, when it is later 'refind' to a new nodemask node 2-3, according to current code it will be add theMPOL_F_LOCALbit and performs 'local' policy acctually. And in future it is 'rebind' again with a nodemask 1-2, it will be restored back to 'prefer' policy with preferred node 1.Honestly I still do not follow the actual problem.
I was confused too, and don't know the original thought behind it. This case 4 was just imagined by reading the code.
Quoted 8 lines
A preferred node is a
_hint_. If you rebind the task to a different cpuset then why should we actually care? The allocator will fallback to the closest node according to the distance metric. Maybe the original code was trying to handle that in some way but I really do fail to understand that code and I strongly suspect it is more likely to overengineered rather than backed by a real usecase. I might be wrong here but then this is an excellent opportunity to clarify all those subtleties.Quoted 8 lines
Quoted 5 lines
From the code, the original special handling may be needed in 3 cases:
get_policy_nodemask()
policy_node()
mempolicy_slab_node()
to not return the presetprefer_nid.I am sorry but I do not follow. What is actually wrong if the preferred node is outside of the cpuset nodemask?
Quoted 8 lines
Sorry, I didn't make it clear. With current code logic, it will perform as 'local' policy, but its mode is kept as 'prefer', so the code still has these tricky bit checking when these APIs are called for this policy. I agree with you that these ping-pong
rebind()may be over engineering, so for this case can we just change the policy from 'prefer' to 'local', and drop the tricky bit manipulation, as the 'prefer' is just a hint, if these rebind misses the target node, there is no need to stick with the 'prefer' policy?
Quoted 4 lines
Again. I really do not understand why we should rebind or mark as local anything here. Is this a documented/expected behavior? What if somebody just changes the cpuset to include the preferred node again. Is it expected to have local preference now?
Good point! Marking 'local' doesn't solve the whole issue. And I didn't find any document defining the semantics.
Quoted 5 lines
I can see you have posted a newer version which I haven't seen yet but this is really better to get resolved before building up more on top. And let me be explicit. I do believe that rebinding preferred policy is just bogus and it should be dropped altogether on the ground that a preference is a mere hint from userspace where to start the allocation.
Yes, the current mpol_rebind_preferred()'s logic is confusing. Let me try to understand it correctly, are you suggesting to do nothing for 'prefer's rebinding regarding MPOL_F_STATIC_NODES and MPOL_F_RELATIVE_NODES, while just setting 'pol->w.cpuset_mems_allowed' to the new nodemask?
Thanks,
Feng
Quoted 7 lines
Unless I am missing something cpusets will be always authoritative for the final placement. The preferred node just acts as a starting point and it should be really preserved when cpusets changes. Otherwise we have a very subtle behavior corner cases.
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 4/4] mm/mempolicy: kill MPOL_F_LOCAL bit
Quoted 1 line · Feng Tang
On Mon, May 31, 2021 at 09:00:25AM +0200, Michal Hocko wrote:
[...]
Quoted 10 lines
Quoted 5 lines
I can see you have posted a newer version which I haven't seen yet but this is really better to get resolved before building up more on top. And let me be explicit. I do believe that rebinding preferred policy is just bogus and it should be dropped altogether on the ground that a preference is a mere hint from userspace where to start the allocation.
Yes, the current mpol_rebind_preferred()'s logic is confusing. Let me try to understand it correctly, are you suggesting to do nothing for 'prefer's rebinding regarding
MPOL_F_STATIC_NODESandMPOL_F_RELATIVE_NODES, while just setting 'pol->w.cpuset_mems_allowed' to the new nodemask?
yes this is exactly what I've had in mind.
Signature · 2 lines
Michal Hocko SUSE Labs
Re: [PATCH v1 4/4] mm/mempolicy: kill MPOL_F_LOCAL bit
Quoted 9 lines · Michal Hocko
Quoted 1 line · Feng Tang
On Mon, May 31, 2021 at 09:00:25AM +0200, Michal Hocko wrote:
[...]
Quoted 6 lines
Quoted 5 lines
I can see you have posted a newer version which I haven't seen yet but this is really better to get resolved before building up more on top. And let me be explicit. I do believe that rebinding preferred policy is just bogus and it should be dropped altogether on the ground that a preference is a mere hint from userspace where to start the allocation.
Quoted 6 lines
Quoted 4 lines
Yes, the current mpol_rebind_preferred()'s logic is confusing. Let me try to understand it correctly, are you suggesting to do nothing for 'prefer's rebinding regarding
MPOL_F_STATIC_NODESandMPOL_F_RELATIVE_NODES, while just setting 'pol->w.cpuset_mems_allowed' to the new nodemask?yes this is exactly what I've had in mind.
Thanks for confirming. Will spin another version.
- Feng
Quoted 3 lines
Signature · 2 lines
Michal Hocko SUSE Labs