Skip to contentSkip to conversation

x86/fpu: track AVX-512 usage of tasks

PATCH Superseded Aubrey Li 6 participants 16 messages Nov 15, 2018 – Nov 23, 2018

Subsystems (2)

v3 of 8 Superseded Latest is v8 →

lore
Share & tools
lore

Aubrey Li

author
#0 lore raw

PATCH v3 1/2 x86/fpu: track AVX-512 usage of tasks

User space tools which do automated task placement need information about AVX-512 usage of tasks, because AVX-512 usage could cause core turbo frequency drop and impact the running task on the sibling CPU.

XSAVE header contains a state-component bitmap, which allows software to discover the state of the init optimization used by XSAVEOPT and XSAVES. Set bits in the bitmap denotes the usage of the components.

AVX-512 component has 3 states, only Hi16_ZMM state causes notable frequency drop. Add per task Hi16_ZMM state tracking to context switch.

The tracking turns on the usage flag immediately, but requires 3 consecutive context switches with no usage to clear it. This decay is required because of AVX-512 using tasks could set Hi16_ZMM state back to the init state themselves.

Cc Peter Zijlstra <[email protected]>
Cc Andi Kleen <[email protected]>
Cc Tim Chen <[email protected]>
Cc Dave Hansen <[email protected]>
Cc Arjan van de Ven <[email protected]>
---
 arch/x86/include/asm/fpu/internal.h | 26 ++++++++++++++++++++++++++
 arch/x86/include/asm/fpu/types.h    |  9 +++++++++
 2 files changed, 35 insertions(+)
arch/x86/include/asm/fpu/internal.h +26 -0
index a38bf5a..f382449 100644
@@ -275,6 +275,31 @@ static inline void copy_fxregs_to_kernel(struct fpu *fpu)
 		     : "D" (st), "m" (*st), "a" (lmask), "d" (hmask)	\
 		     : "memory")
 
+#define	HI16ZMM_STATE_DECAY_COUNT	3
+/*
+ * This function is called during context switch to update Hi16_ZMM state
+ */
+static inline void update_hi16zmm_state(struct fpu *fpu)
+{
+	/*
+	 * XSAVE header contains a state-component bitmap(xfeatures),
+	 * which allows software to discover the state of the init
+	 * optimization used by XSAVEOPT and XSAVES.
+	 *
+	 * Hi16_ZMM state(one state of AVX-512 component) is tracked here
+	 * because its usage could cause notable core turbo frequency drop.
+	 *
+	 * AVX512-using tasks could set Hi16_ZMM state back to the init
+	 * state themselves. Thus, this tracking mechanism can miss.
+	 * The decay usage ensures that false-negatives do not immediately
+	 * make a task be considered as not using Hi16_ZMM registers.
+	 */
+	if (fpu->state.xsave.header.xfeatures & XFEATURE_MASK_Hi16_ZMM)
+		fpu->hi16zmm_usage = HI16ZMM_STATE_DECAY_COUNT;
+	else if (fpu->hi16zmm_usage)
+		fpu->hi16zmm_usage--;
+}
+
 /*
  * This function is called only during boot time when x86 caps are not set
  * up and alternative can not be used yet.
@@ -411,6 +436,7 @@ static inline int copy_fpregs_to_fpstate(struct fpu *fpu)
 {
 	if (likely(use_xsave())) {
 		copy_xregs_to_kernel(&fpu->state.xsave);
+		update_hi16zmm_state(fpu);
 		return 1;
 	}
 
arch/x86/include/asm/fpu/types.h +9 -0
index 202c539..c0c7577 100644
@@ -303,6 +303,15 @@ struct fpu {
 	unsigned char			initialized;
 
 	/*
+	 * @hi16zmm_usage:
+	 *
+	 * Records the usage of the upper 16 AVX512 registers: ZMM16-ZMM31.
+	 * A value of non-zero is used to indicate whether there is valid
+	 * state in these AVX512 registers.
+	 */
+	unsigned char			hi16zmm_usage;
+
+	/*
 	 * @state:
 	 *
 	 * In-memory copy of all FPU registers that we save/restore
Signature · 1 line
2.7.4
author
#1 lore raw

PATCH v3 2/2 proc: add /proc/<pid>/arch_state

Add a /proc/<pid>/arch_state interface to expose per-task cpu specific state values.

Exposing AVX-512 Hi16_ZMM registers usage is for the user space job scheduler to cluster AVX-512 using tasks together, because these tasks could cause core turbo frequency drop.

Cc Peter Zijlstra <[email protected]>
Cc Andi Kleen <[email protected]>
Cc Tim Chen <[email protected]>
Cc Arjan van de Ven <[email protected]>
---
 arch/x86/kernel/fpu/xstate.c | 16 ++++++++++++++++
 fs/proc/base.c               | 13 +++++++++++++
 2 files changed, 29 insertions(+)
arch/x86/kernel/fpu/xstate.c +16 -0
index 87a57b7..10224ee 100644
@@ -7,6 +7,7 @@
 #include <linux/cpu.h>
 #include <linux/mman.h>
 #include <linux/pkeys.h>
+#include <linux/seq_file.h>
 
 #include <asm/fpu/api.h>
 #include <asm/fpu/internal.h>
@@ -1245,3 +1246,18 @@ int copy_user_to_xstate(struct xregs_state *xsave, const void __user *ubuf)
 
 	return 0;
 }
+
+/*
+ * report CPU specific thread state
+ */
+void arch_thread_state(struct seq_file *m, struct task_struct *task)
+{
+	/*
+	 * Report AVX-512 Hi16_ZMM registers usage
+	 */
+	if (task->thread.fpu.hi16zmm_usage)
+		seq_putc(m, '1');
+	else
+		seq_putc(m, '0');
+	seq_putc(m, '\n');
+}
fs/proc/base.c +13 -0
index aaffc0c..efd51ec 100644
@@ -2893,6 +2893,17 @@ static int proc_pid_patch_state(struct seq_file *m, struct pid_namespace *ns,
 }
 #endif /* CONFIG_LIVEPATCH */
 
+void __weak arch_thread_state(struct seq_file *m, struct task_struct *task)
+{
+}
+
+static int proc_pid_arch_state(struct seq_file *m, struct pid_namespace *ns,
+				 struct pid *pid, struct task_struct *task)
+{
+	arch_thread_state(m, task);
+	return 0;
+}
+
 /*
  * Thread groups
  */
@@ -2994,6 +3005,7 @@ static const struct pid_entry tgid_base_stuff[] = {
 #ifdef CONFIG_LIVEPATCH
 	ONE("patch_state",  S_IRUSR, proc_pid_patch_state),
 #endif
+	ONE("arch_state",  S_IRUSR, proc_pid_arch_state),
 };
 
 static int proc_tgid_base_readdir(struct file *file, struct dir_context *ctx)
@@ -3372,6 +3384,7 @@ static const struct pid_entry tid_base_stuff[] = {
 #ifdef CONFIG_LIVEPATCH
 	ONE("patch_state",  S_IRUSR, proc_pid_patch_state),
 #endif
+	ONE("arch_state",  S_IRUSR, proc_pid_arch_state),
 };
 
 static int proc_tid_base_readdir(struct file *file, struct dir_context *ctx)
Signature · 1 line
2.7.4
#2 lore raw

Re: [PATCH v3 2/2] proc: add /proc/<pid>/arch_state

arch/x86/kernel/fpu/xstate.c int copy_user_to_xstate(struct xregs_state *xsave, const void __user *ubuf) · line 1263

Quoted 11 lines · Aubrey Li
arch/x86/kernel/fpu/xstate.c +11 -0
+void arch_thread_state(struct seq_file *m, struct task_struct *task)
+{
+	/*
+	 * Report AVX-512 Hi16_ZMM registers usage
+	 */
+	if (task->thread.fpu.hi16zmm_usage)
+		seq_putc(m, '1');
+	else
+		seq_putc(m, '0');
+	seq_putc(m, '\n');
+}

Am I reading this right that this file just dumps out a plain 0 or 1 based on the internal kernel state? BTW, there's no example of the output in the changelog, so it's rather hard to tell if my guess is right. (Hint, hint).

If so, I'd really prefer you not do this. We have /proc/$pid/stat to stand as a disaster in this regard. It is essentially non-human-readable gibberish because it's impossible to tell what the values mean without a decoder ring.

If we go down this road, we need a file along the lines of /proc/$pid/status.

But, either way, this is a new ABI that we need to consider carefully. It needs documentation. For instance, will this really mean "Hi16_ZMM user" from now until the end of time? Or, does it just mean "group me with other tasks that have this bit set"?

#3 lore raw

Re: [PATCH v3 2/2] proc: add /proc/<pid>/arch_state

Quoted 18 lines · Dave Hansen

arch/x86/kernel/fpu/xstate.c int copy_user_to_xstate(struct xregs_state *xsave, const void __user *ubuf) · line 1263

Quoted 11 lines · Aubrey Li
arch/x86/kernel/fpu/xstate.c +11 -0
+void arch_thread_state(struct seq_file *m, struct task_struct *task)
+{
+	/*
+	 * Report AVX-512 Hi16_ZMM registers usage
+	 */
+	if (task->thread.fpu.hi16zmm_usage)
+		seq_putc(m, '1');
+	else
+		seq_putc(m, '0');
+	seq_putc(m, '\n');
+}

Am I reading this right that this file just dumps out a plain 0 or 1 based on the internal kernel state? BTW, there's no example of the output in the changelog, so it's rather hard to tell if my guess is right. (Hint, hint).

Quoted 4 lines

If so, I'd really prefer you not do this. We have /proc/$pid/stat to stand as a disaster in this regard. It is essentially non-human-readable gibberish because it's impossible to tell what the values mean without a decoder ring.

Yes, I'm following /proc/$pid/stat format, as I think this interface is not for the end user, but for developer and user space job scheduler. So I guess this style might be okay.

Quoted 3 lines

If we go down this road, we need a file along the lines of /proc/$pid/status.

I checked /proc/$pid/status, all common information to architectures. That's why I want to open a new interface to CPU specific state.

Quoted 6 lines

But, either way, this is a new ABI that we need to consider carefully. It needs documentation. For instance, will this really mean "Hi16_ZMM user" from now until the end of time? Or, does it just mean "group me with other tasks that have this bit set"?

I'm open to this interface. Let's wait to see if there are more comments and suggestions.

Thanks,
-Aubrey

#4 lore raw

Re: [PATCH v3 2/2] proc: add /proc/<pid>/arch_state

In reply to Aubrey Li
Quoted 6 lines · Aubrey Li

Add a /proc/<pid>/arch_state interface to expose per-task cpu specific state values.

Exposing AVX-512 Hi16_ZMM registers usage is for the user space job scheduler to cluster AVX-512 using tasks together, because these tasks could cause core turbo frequency drop.

I still don't much like the name; how about arch_simd_state ? Also, since we're printing an integer, I still prefer we go print the turbo license level. I know level 1 isn't too interesting atm, but consider future hardware widening the thing again and us growing level 3 or something.

Also; you were going to shop around with the other architectures to see what they want/need for this interface. I see nothing on that.

#5 lore raw

Re: [PATCH v3 2/2] proc: add /proc/<pid>/arch_state

Quoted 9 lines · Peter Zijlstra
Quoted 6 lines · Aubrey Li

Add a /proc/<pid>/arch_state interface to expose per-task cpu specific state values.

Exposing AVX-512 Hi16_ZMM registers usage is for the user space job scheduler to cluster AVX-512 using tasks together, because these tasks could cause core turbo frequency drop.

I still don't much like the name; how about arch_simd_state ?

My intention is
#cat /proc/<pid>/arch_state
0 1 0

Here, the first "0" denotes simd_state, and the second "1" denotes another cpu specific feature(may come soon), and can be extended.

But sure I can limit it to simd_state and change the name in the patch.

Quoted 5 lines

Also,
since we're printing an integer, I still prefer we go print the turbo license level. I know level 1 isn't too interesting atm, but consider future hardware widening the thing again and us growing level 3 or something.

The problem is, FWICT, the bits in XSAVE buffer is not exactly mapped to the turbo license level, so we can't print turbo license level correctly, or the first patch need rework for that.

Quoted 4 lines

Also; you were going to shop around with the other architectures to see what they want/need for this interface. I see nothing on that.

I'm open for your suggestion, :)

Thanks,
-Aubrey

#6 lore raw

Re: [PATCH v3 2/2] proc: add /proc/<pid>/arch_state

Quoted 4 lines · Aubrey
Quoted 3 lines

Also; you were going to shop around with the other architectures to see what they want/need for this interface. I see nothing on that.

I'm open for your suggestion, :)

Well, we have linux-arch and the various maintainers are also listed in MAINTAINERS. Go forth and ask..

#7 lore raw

Re: [PATCH v3 2/2] proc: add /proc/<pid>/arch_state

Quoted 8 lines · Peter Zijlstra
Quoted 4 lines · Aubrey
Quoted 3 lines

Also; you were going to shop around with the other architectures to see what they want/need for this interface. I see nothing on that.

I'm open for your suggestion, :)

Well, we have linux-arch and the various maintainers are also listed in MAINTAINERS. Go forth and ask..

Ok, so I googled a wee bit (you could have too).

There's not that many architectures that build big hot chips (powerpc,x86,arm64,s390) (mips, sparc64 and ia64 are pretty dead I think, although the Fujitsu Sparc M10 X+/X SIMD looked like it could be 'fun').

Of those, powerpc altivec doesn't seem to be very wide, but you'd have to ask the power folks. Same for s390 z13.

The Fujitsu/ARM64-SVE stuff looks like it can be big and hot.

And RISC-V has was vector extention, but I don't think anybody is actually building big hot versions of that just yet.

#8 lore raw

Re: [PATCH v3 2/2] proc: add /proc/<pid>/arch_state

Quoted 17 lines · On Wed, 21 Nov 2018 01:53:50 PST (-0800), [email protected] wrote:
Quoted 8 lines · Peter Zijlstra
Quoted 4 lines · Aubrey
Quoted 3 lines

Also; you were going to shop around with the other architectures to see what they want/need for this interface. I see nothing on that.

I'm open for your suggestion, :)

Well, we have linux-arch and the various maintainers are also listed in MAINTAINERS. Go forth and ask..

Ok, so I googled a wee bit (you could have too).

There's not that many architectures that build big hot chips (powerpc,x86,arm64,s390) (mips, sparc64 and ia64 are pretty dead I think, although the Fujitsu Sparc M10 X+/X SIMD looked like it could be 'fun').

Quoted 7 lines

Of those, powerpc altivec doesn't seem to be very wide, but you'd have to ask the power folks. Same for s390 z13.

The Fujitsu/ARM64-SVE stuff looks like it can be big and hot.

And RISC-V has was vector extention, but I don't think anybody is actually building big hot versions of that just yet.

We don't actually have a vector extension yet, but there's supposed to be a draft out in 2 weeks. The plan is that this draft will be sufficiently long-lived that we can start software implementation work. While I don't believe it's intended that hardware implementations become available using this draft specification, these things tend to take a life of their own. I'd be pretty surprised if we don't end up seeing hardware implementations of this draft specification.

I don't know if they'll be big and hot, though -- the whole point of the vector extension is that we can build chips that aren't that big or hot :)

On a more serious note, in RISC-V land we've attempted to make mcontext extensible and plan on shimming all the additional architectural state into there. Thus, I don't think this interface is particularly useful for us.

I also don't like this "file full of 1s and 0s" interface, but it's certainly not my place to shoot it down. In RISC-V land we're trying very hard to carefully examine any user-visible ABI to ensure it's something we're willing to keep around for ever, and this doesn't seem like something that fits that mold.

#9 lore raw

Re: [PATCH v3 2/2] proc: add /proc/<pid>/arch_state

In reply to Peter Zijlstra
Quoted 17 lines · Peter Zijlstra
Quoted 8 lines · Peter Zijlstra
Quoted 4 lines · Aubrey
Quoted 3 lines

Also; you were going to shop around with the other architectures to see what they want/need for this interface. I see nothing on that.

I'm open for your suggestion, :)

Well, we have linux-arch and the various maintainers are also listed in MAINTAINERS. Go forth and ask..

Ok, so I googled a wee bit (you could have too).

There's not that many architectures that build big hot chips (powerpc,x86,arm64,s390) (mips, sparc64 and ia64 are pretty dead I think, although the Fujitsu Sparc M10 X+/X SIMD looked like it could be 'fun').

Quoted 8 lines

Of those, powerpc altivec doesn't seem to be very wide, but you'd have to ask the power folks. Same for s390 z13.

The Fujitsu/ARM64-SVE stuff looks like it can be big and hot.

And RISC-V has was vector extention, but I don't think anybody is actually building big hot versions of that just yet.

Thanks Peter. Add more maintainers here.

On some x86 architectures, the tasks using simd instruction(AVX512 particularly) need to be dealt with specially against the tasks not using simd instruction. I proposed an interface to expose such CPU specific information for the user space tools to apply different scheduling policies.

The interface can be refined to be the format as /proc/<pid>/status. Not sure if it's useful to any other architectures.

Welcome any comments.

Thanks,
-Aubrey

#10 lore raw

Re: [PATCH v3 2/2] proc: add /proc/<pid>/arch_state

Quoted 33 lines · Aubrey
Quoted 17 lines · Peter Zijlstra
Quoted 8 lines · Peter Zijlstra
Quoted 4 lines · Aubrey
Quoted 3 lines

Also; you were going to shop around with the other architectures to see what they want/need for this interface. I see nothing on that.

I'm open for your suggestion, :)

Well, we have linux-arch and the various maintainers are also listed in MAINTAINERS. Go forth and ask..

Ok, so I googled a wee bit (you could have too).

There's not that many architectures that build big hot chips (powerpc,x86,arm64,s390) (mips, sparc64 and ia64 are pretty dead I think, although the Fujitsu Sparc M10 X+/X SIMD looked like it could be 'fun').

Quoted 8 lines

Of those, powerpc altivec doesn't seem to be very wide, but you'd have to ask the power folks. Same for s390 z13.

The Fujitsu/ARM64-SVE stuff looks like it can be big and hot.

And RISC-V has was vector extention, but I don't think anybody is actually building big hot versions of that just yet.

Thanks Peter. Add more maintainers here.

On some x86 architectures, the tasks using simd instruction(AVX512 particularly) need to be dealt with specially against the tasks not using simd instruction. I proposed an interface to expose such CPU specific information for the user space tools to apply different scheduling policies.

Quoted 4 lines

The interface can be refined to be the format as /proc/<pid>/status. Not sure if it's useful to any other architectures.

Welcome any comments.

For SVE:

We currently monitor SVE use by trapping only. We also made an ABI decision that a syscall throws away the task's SVE state -- this falls out naturally from the fact that the SVE state is caller-save for regular function calls in the AArch64 ABI.

There isn't an explicit means like VZEROUPPER for userspace to mark the SVE state as non-live without entering the kernel today.

Currently I expose as little detail to userspace as possible regarding how/when SVE is enabled/disabled or used.

For the /proc interface:

It would be nice to expose some information to userspace about when/ where major hardware functional units are in use, but beyond the information already supplied by hardware perf events, it's not obvious what should be exposed.

AFAICT, the exposed flags would be partly an arbitrary artifact of kernel implementation details: i.e., how often and when the kernel saves/restores the task's state may affect the pattern of observed values in non-trivial ways.

For SVE today, a task that does a lot of syscalls may appear to be using SVE less than a second task that does fewer syscalls but is otherwise identical -- simply because a syscall is our only way to detect that SVE is not in use today.

This kind of issue means that userspace may struggle to make good decisions using this data: instead it's going to rely on some kind of tuning which may become wrong as soon as the workload, kernel version or hardware changes.

A /proc/<pid>/file would need to be polled (which doesn't sound great) and also suffers from all the usual /proc raciness.

Cheers
---Dave

#11 lore raw
In reply to Aubrey Li
Quoted 2 lines · Aubrey Li

AVX-512 component has 3 states, only Hi16_ZMM state causes notable frequency drop. Add per task Hi16_ZMM state tracking to context switch.

Just curious, but is there any public documentation of this? It seems really odd to me that something using the same AVX-512 instructions on some low-numbered registers would behave differently than the same instructions on some high-numbered registers. I'm not saying this is wrong, but it's certainly counter-intuitive and I think that begs for some more explanation.

Quoted 4 lines

The tracking turns on the usage flag immediately, but requires 3 consecutive context switches with no usage to clear it. This decay is required because of AVX-512 using tasks could set Hi16_ZMM state back to the init state themselves.

It would be nice to not assume that folks reading this changelog know what XSAVE 'init states' are. In fact, that comment you have in the function below would be great here, but probably shouldn't be in the comment.

I would say it even more strongly than that: Part of the best practices for using AVX-512 is to use the VZEROUPPER instruction to zero out some state when the AVX-512 operation is finished. Unlike all the other FPU and AVX state before it, this means that the Hi16_ZMM is expected to frequently transition back to the "init state" in normal use. This might cause this detection mechanism to frequently miss tasks that actually use AVX-512. To fix that, add a decay.

Quoted 19 lines
Cc Peter Zijlstra <[email protected]>
Cc Andi Kleen <[email protected]>
Cc Tim Chen <[email protected]>
Cc Dave Hansen <[email protected]>
Cc Arjan van de Ven <[email protected]>
---
 arch/x86/include/asm/fpu/internal.h | 26 ++++++++++++++++++++++++++
 arch/x86/include/asm/fpu/types.h    |  9 +++++++++
 2 files changed, 35 insertions(+)
arch/x86/include/asm/fpu/internal.h +0 -0
index a38bf5a..f382449 100644
@@ -275,6 +275,31 @@ static inline void copy_fxregs_to_kernel(struct fpu *fpu)
 		     : "D" (st), "m" (*st), "a" (lmask), "d" (hmask)	\
 		     : "memory")
 

arch/x86/include/asm/fpu/internal.h static inline void copy_fxregs_to_kernel(struct fpu *fpu) · line 287

Quoted 10 lines
arch/x86/include/asm/fpu/internal.h +10 -0
+#define	HI16ZMM_STATE_DECAY_COUNT	3
+/*
+ * This function is called during context switch to update Hi16_ZMM state
+ */
+static inline void update_hi16zmm_state(struct fpu *fpu)
+{
+	/*
+	 * XSAVE header contains a state-component bitmap(xfeatures),
+	 * which allows software to discover the state of the init
+	 * optimization used by XSAVEOPT and XSAVES.

I don't think we need the XSAVE background here. Can you put this in the changelog?

arch/x86/include/asm/fpu/internal.h static inline void copy_fxregs_to_kernel(struct fpu *fpu) · line 290

Quoted 2 lines
arch/x86/include/asm/fpu/internal.h +2 -0
+	 * Hi16_ZMM state(one state of AVX-512 component) is tracked here
+	 * because its usage could cause notable core turbo frequency drop.

I'd leave just this part of the comment.

arch/x86/include/asm/fpu/internal.h static inline void copy_fxregs_to_kernel(struct fpu *fpu) · line 293

Quoted 2 lines
arch/x86/include/asm/fpu/internal.h +2 -0
+	 * AVX512-using tasks could set Hi16_ZMM state back to the init
+	 * state themselves. Thus, this tracking mechanism can miss.

Can you make this a stronger statement, just like the changelog?

arch/x86/include/asm/fpu/internal.h static inline void copy_fxregs_to_kernel(struct fpu *fpu) · line 296

Quoted 3 lines
arch/x86/include/asm/fpu/internal.h +3 -0
+	 * The decay usage ensures that false-negatives do not immediately
+	 * make a task be considered as not using Hi16_ZMM registers.
+	 */

To ensure that false-negatives do not immediately show up, decay the usage count over time.

Quoted 6 lines
arch/x86/include/asm/fpu/internal.h +5 -0
+	 *
+	 * Records the usage of the upper 16 AVX512 registers: ZMM16-ZMM31.
+	 * A value of non-zero is used to indicate whether there is valid
+	 * state in these AVX512 registers.
+	 */
 

arch/x86/include/asm/fpu/internal.h static inline void copy_fxregs_to_kernel(struct fpu *fpu)

Quoted 10 lines
arch/x86/include/asm/fpu/internal.h +8 -0
 
 	/*
+	 * @hi16zmm_usage:
+	 *
+	 * Records the usage of the upper 16 AVX512 registers: ZMM16-ZMM31.
+	 * A value of non-zero is used to indicate whether there is valid
+	 * state in these AVX512 registers.
+	 */
+	unsigned char			hi16zmm_usage;
+

Nit: With the decay, this does not indicate register state. It indicates whether the registers recently had state.

#12 lore raw
Quoted 10 lines · Dave Hansen
Quoted 2 lines · Aubrey Li

AVX-512 component has 3 states, only Hi16_ZMM state causes notable frequency drop. Add per task Hi16_ZMM state tracking to context switch.

Just curious, but is there any public documentation of this? It seems really odd to me that something using the same AVX-512 instructions on some low-numbered registers would behave differently than the same instructions on some high-numbered registers. I'm not saying this is wrong, but it's certainly counter-intuitive and I think that begs for some more explanation.

Yes, Intel 64 and IA-32 Architectures software developer's Manual mentioned this in performance event CORE_POWER.LVL2_TURBO_LICENSE.

"Core cycles where the core was running with power delivery for license level 2 (introduced in Skylake Server microarchitecture). This includes high current AVX 512-bit instructions."

I translated license level 2 to frequency drop.

Thanks,
-Aubrey

#13 lore raw
Quoted 12 lines · Aubrey
Quoted 10 lines · Dave Hansen
Quoted 2 lines · Aubrey Li

AVX-512 component has 3 states, only Hi16_ZMM state causes notable frequency drop. Add per task Hi16_ZMM state tracking to context switch.

Just curious, but is there any public documentation of this? It seems really odd to me that something using the same AVX-512 instructions on some low-numbered registers would behave differently than the same instructions on some high-numbered registers. I'm not saying this is wrong, but it's certainly counter-intuitive and I think that begs for some more explanation.

Quoted 8 lines

Yes, Intel 64 and IA-32 Architectures software developer's Manual mentioned this in performance event CORE_POWER.LVL2_TURBO_LICENSE.

"Core cycles where the core was running with power delivery for license level 2 (introduced in Skylake Server microarchitecture). This includes high current AVX 512-bit instructions."

I translated license level 2 to frequency drop.

OK, but that talks about AVX 512 and not specifically about Hi16_ZMM's impact which is what this patch measures. Are the Hi16_ZMM intricacies documented anywhere?

#14 lore raw
In reply to Li, Aubrey
Quoted 5 lines · Aubrey

"Core cycles where the core was running with power delivery for license level 2 (introduced in Skylake Server microarchitecture). This includes high current AVX 512-bit instructions."

I translated license level 2 to frequency drop.

BTW, the "high" in that text: "high-current AVX 512-bit instructions" is talking about high-current, not "high ... instructions" or high-numbered registers. I think that might be the source of some of the confusion about which XSAVE state needs to be examined.

Just to be clear: there are 3 AVX-512 XSAVE states:

        XFEATURE_OPMASK,
        XFEATURE_ZMM_Hi256,
        XFEATURE_Hi16_ZMM,

I honestly don't know what XFEATURE_OPMASK does. It does not appear to be affected by VZEROUPPER (although VZEROUPPER's SDM documentation isn't looking too great).

But, XFEATURE_ZMM_Hi256 is used for the upper 256 bits of the registers ZMM0-ZMM15. Those are AVX-512-only registers. The only way to get data into XFEATURE_ZMM_Hi256 state is by using AVX512 instructions.

XFEATURE_Hi16_ZMM is the same. The only way to get state in there is with AVX512 instructions.

So, first of all, I think you *MUST* check XFEATURE_ZMM_Hi256 and XFEATURE_Hi16_ZMM. That's without question.

It's probably *possible* to run AVX512 instructions by loading state into the YMM register and then executing AVX512 instructions that only write to memory and never to register state. That *might* allow XFEATURE_Hi16_ZMM and XFEATURE_ZMM_Hi256 to stay in the init state, but for the frequency to be affected since AVX512 instructions _are_ executing. But, there's no way to detect this situation from XSAVE states themselves.

#15 lore raw
Quoted 26 lines · Dave Hansen
Quoted 5 lines · Aubrey

"Core cycles where the core was running with power delivery for license level 2 (introduced in Skylake Server microarchitecture). This includes high current AVX 512-bit instructions."

I translated license level 2 to frequency drop.

BTW, the "high" in that text: "high-current AVX 512-bit instructions" is talking about high-current, not "high ... instructions" or high-numbered registers. I think that might be the source of some of the confusion about which XSAVE state needs to be examined.

Just to be clear: there are 3 AVX-512 XSAVE states:

        XFEATURE_OPMASK,
        XFEATURE_ZMM_Hi256,
        XFEATURE_Hi16_ZMM,

I honestly don't know what XFEATURE_OPMASK does. It does not appear to be affected by VZEROUPPER (although VZEROUPPER's SDM documentation isn't looking too great).

But, XFEATURE_ZMM_Hi256 is used for the upper 256 bits of the registers ZMM0-ZMM15. Those are AVX-512-only registers. The only way to get data into XFEATURE_ZMM_Hi256 state is by using AVX512 instructions.

Quoted 5 lines

XFEATURE_Hi16_ZMM is the same. The only way to get state in there is with AVX512 instructions.

So, first of all, I think you *MUST* check XFEATURE_ZMM_Hi256 and XFEATURE_Hi16_ZMM. That's without question.

No, XFEATURE_ZMM_Hi256 does not request turbo license 2, so it's less interested to us.

Quoted 9 lines

It's probably *possible* to run AVX512 instructions by loading state into the YMM register and then executing AVX512 instructions that only write to memory and never to register state. That *might* allow XFEATURE_Hi16_ZMM and XFEATURE_ZMM_Hi256 to stay in the init state, but for the frequency to be affected since AVX512 instructions _are_ executing. But, there's no way to detect this situation from XSAVE states themselves.

Andi should have more details on this. FWICT, not all AVX512 instructions has high current, those only touching memory do not cause notable frequency drop.

Thanks,
-Aubrey