* [PATCH v3 0/2] RISC-V: hwprobe: Misaligned scalar perf fix and rename @ 2024-06-27 17:22 Evan Green 2024-06-27 17:22 ` [PATCH v3 1/2] RISC-V: hwprobe: Add MISALIGNED_PERF key Evan Green 2024-06-27 17:22 ` [PATCH v3 2/2] RISC-V: hwprobe: Add SCALAR to misaligned perf defines Evan Green 0 siblings, 2 replies; 5+ messages in thread From: Evan Green @ 2024-06-27 17:22 UTC (permalink / raw) To: Palmer Dabbelt Cc: Yangyu Chen, Evan Green, Albert Ou, Alexandre Ghiti, Andrew Jones, Andy Chiu, Ben Dooks, Björn Töpel, Charlie Jenkins, Clément Léger, Conor Dooley, Costa Shulyupin, Erick Archer, Jonathan Corbet, Paul Walmsley, linux-doc, linux-kernel, linux-riscv The CPUPERF0 hwprobe key was documented and identified in code as a bitmask value, but its contents were an enum. This produced incorrect behavior in conjunction with the WHICH_CPUS hwprobe flag. The first patch in this series fixes the bitmask/enum problem by creating a new hwprobe key that returns the same data, but is properly described as a value instead of a bitmask. The second patch renames the value definitions in preparation for adding vector misaligned access info. As of this version, the old defines are kept in place to maintain source compatibility with older userspace programs. Changes in v3: - Further documentation wordsmithing (Conor) - Leave the old defines in place (Conor, Palmer) Changes in v2: - Clarified the distinction of slow and fast refers to misaligned word accesses. Previously it just said misaligned accesses, leaving it ambiguous as to which type of access was measured. - Removed shifts in values (Andrew) - Renamed key to RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF (Palmer) - Added patch to rename misaligned perf key values (Palmer) Evan Green (2): RISC-V: hwprobe: Add MISALIGNED_PERF key RISC-V: hwprobe: Add SCALAR to misaligned perf defines Documentation/arch/riscv/hwprobe.rst | 30 +++++++++++++--------- arch/riscv/include/asm/hwprobe.h | 2 +- arch/riscv/include/uapi/asm/hwprobe.h | 6 +++++ arch/riscv/kernel/sys_hwprobe.c | 11 ++++---- arch/riscv/kernel/traps_misaligned.c | 6 ++--- arch/riscv/kernel/unaligned_access_speed.c | 12 ++++----- 6 files changed, 40 insertions(+), 27 deletions(-) -- 2.34.1 ^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH v3 1/2] RISC-V: hwprobe: Add MISALIGNED_PERF key 2024-06-27 17:22 [PATCH v3 0/2] RISC-V: hwprobe: Misaligned scalar perf fix and rename Evan Green @ 2024-06-27 17:22 ` Evan Green 2024-06-27 17:22 ` [PATCH v3 2/2] RISC-V: hwprobe: Add SCALAR to misaligned perf defines Evan Green 1 sibling, 0 replies; 5+ messages in thread From: Evan Green @ 2024-06-27 17:22 UTC (permalink / raw) To: Palmer Dabbelt Cc: Yangyu Chen, Evan Green, Charlie Jenkins, Andrew Jones, Albert Ou, Andy Chiu, Clément Léger, Conor Dooley, Costa Shulyupin, Jonathan Corbet, Paul Walmsley, linux-doc, linux-kernel, linux-riscv RISCV_HWPROBE_KEY_CPUPERF_0 was mistakenly flagged as a bitmask in hwprobe_key_is_bitmask(), when in reality it was an enum value. This causes problems when used in conjunction with RISCV_HWPROBE_WHICH_CPUS, since SLOW, FAST, and EMULATED have values whose bits overlap with each other. If the caller asked for the set of CPUs that was SLOW or EMULATED, the returned set would also include CPUs that were FAST. Introduce a new hwprobe key, RISCV_HWPROBE_KEY_MISALIGNED_PERF, which returns the same values in response to a direct query (with no flags), but is properly handled as an enumerated value. As a result, SLOW, FAST, and EMULATED are all correctly treated as distinct values under the new key when queried with the WHICH_CPUS flag. Leave the old key in place to avoid disturbing applications which may have already come to rely on the key, with or without its broken behavior with respect to the WHICH_CPUS flag. Fixes: e178bf146e4b ("RISC-V: hwprobe: Introduce which-cpus flag") Signed-off-by: Evan Green <evan@rivosinc.com> Reviewed-by: Charlie Jenkins <charlie@rivosinc.com> Reviewed-by: Andrew Jones <ajones@ventanamicro.com> --- Changes in v3: - Further documentation wordsmithing (Conor) Changes in v2: - Clarified the distinction of slow and fast refers to misaligned word accesses. Previously it just said misaligned accesses, leaving it ambiguous as to which type of access was measured. - Removed shifts in values (Andrew) - Renamed key to RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF (Palmer) Documentation/arch/riscv/hwprobe.rst | 20 +++++++++++++------- arch/riscv/include/asm/hwprobe.h | 2 +- arch/riscv/include/uapi/asm/hwprobe.h | 1 + arch/riscv/kernel/sys_hwprobe.c | 1 + 4 files changed, 16 insertions(+), 8 deletions(-) diff --git a/Documentation/arch/riscv/hwprobe.rst b/Documentation/arch/riscv/hwprobe.rst index 25d783be2878..7121a00a8464 100644 --- a/Documentation/arch/riscv/hwprobe.rst +++ b/Documentation/arch/riscv/hwprobe.rst @@ -235,8 +235,13 @@ The following keys are defined: supported as defined in the RISC-V ISA manual starting from commit c732a4f39a4 ("Zcmop is ratified/1.0"). -* :c:macro:`RISCV_HWPROBE_KEY_CPUPERF_0`: A bitmask that contains performance - information about the selected set of processors. +* :c:macro:`RISCV_HWPROBE_KEY_CPUPERF_0`: Deprecated. Returns similar values to + :c:macro:`RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF`, but the key was + mistakenly classified as a bitmask rather than a value. + +* :c:macro:`RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF`: An enum value describing + the performance of misaligned scalar native word accesses on the selected set + of processors. * :c:macro:`RISCV_HWPROBE_MISALIGNED_UNKNOWN`: The performance of misaligned accesses is unknown. @@ -245,12 +250,13 @@ The following keys are defined: emulated via software, either in or below the kernel. These accesses are always extremely slow. - * :c:macro:`RISCV_HWPROBE_MISALIGNED_SLOW`: Misaligned accesses are slower - than equivalent byte accesses. Misaligned accesses may be supported - directly in hardware, or trapped and emulated by software. + * :c:macro:`RISCV_HWPROBE_MISALIGNED_SLOW`: Misaligned native word + sized accesses are slower than the equivalent quantity of byte accesses. + Misaligned accesses may be supported directly in hardware, or trapped and + emulated by software. - * :c:macro:`RISCV_HWPROBE_MISALIGNED_FAST`: Misaligned accesses are faster - than equivalent byte accesses. + * :c:macro:`RISCV_HWPROBE_MISALIGNED_FAST`: Misaligned native word + sized accesses are faster than the equivalent quantity of byte accesses. * :c:macro:`RISCV_HWPROBE_MISALIGNED_UNSUPPORTED`: Misaligned accesses are not supported at all and will generate a misaligned address fault. diff --git a/arch/riscv/include/asm/hwprobe.h b/arch/riscv/include/asm/hwprobe.h index 630507dff5ea..150a9877b0af 100644 --- a/arch/riscv/include/asm/hwprobe.h +++ b/arch/riscv/include/asm/hwprobe.h @@ -8,7 +8,7 @@ #include <uapi/asm/hwprobe.h> -#define RISCV_HWPROBE_MAX_KEY 6 +#define RISCV_HWPROBE_MAX_KEY 7 static inline bool riscv_hwprobe_key_is_valid(__s64 key) { diff --git a/arch/riscv/include/uapi/asm/hwprobe.h b/arch/riscv/include/uapi/asm/hwprobe.h index 920fc6a586c9..7ebb2f2cc4cf 100644 --- a/arch/riscv/include/uapi/asm/hwprobe.h +++ b/arch/riscv/include/uapi/asm/hwprobe.h @@ -79,6 +79,7 @@ struct riscv_hwprobe { #define RISCV_HWPROBE_MISALIGNED_UNSUPPORTED (4 << 0) #define RISCV_HWPROBE_MISALIGNED_MASK (7 << 0) #define RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE 6 +#define RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF 7 /* Increase RISCV_HWPROBE_MAX_KEY when adding items. */ /* Flags */ diff --git a/arch/riscv/kernel/sys_hwprobe.c b/arch/riscv/kernel/sys_hwprobe.c index 3d1aa13a0bb2..b18639020c61 100644 --- a/arch/riscv/kernel/sys_hwprobe.c +++ b/arch/riscv/kernel/sys_hwprobe.c @@ -223,6 +223,7 @@ static void hwprobe_one_pair(struct riscv_hwprobe *pair, break; case RISCV_HWPROBE_KEY_CPUPERF_0: + case RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF: pair->value = hwprobe_misaligned(cpus); break; -- 2.34.1 ^ permalink raw reply related [flat|nested] 5+ messages in thread
* [PATCH v3 2/2] RISC-V: hwprobe: Add SCALAR to misaligned perf defines 2024-06-27 17:22 [PATCH v3 0/2] RISC-V: hwprobe: Misaligned scalar perf fix and rename Evan Green 2024-06-27 17:22 ` [PATCH v3 1/2] RISC-V: hwprobe: Add MISALIGNED_PERF key Evan Green @ 2024-06-27 17:22 ` Evan Green 2024-08-07 17:56 ` Charlie Jenkins 1 sibling, 1 reply; 5+ messages in thread From: Evan Green @ 2024-06-27 17:22 UTC (permalink / raw) To: Palmer Dabbelt Cc: Yangyu Chen, Evan Green, Charlie Jenkins, Albert Ou, Alexandre Ghiti, Andrew Jones, Andy Chiu, Ben Dooks, Björn Töpel, Clément Léger, Conor Dooley, Costa Shulyupin, Erick Archer, Jonathan Corbet, Paul Walmsley, linux-doc, linux-kernel, linux-riscv In preparation for misaligned vector performance hwprobe keys, rename the hwprobe key values associated with misaligned scalar accesses to include the term SCALAR. Leave the old defines in place to maintain source compatibility. This change is intended to be a functional no-op. Signed-off-by: Evan Green <evan@rivosinc.com> Reviewed-by: Charlie Jenkins <charlie@rivosinc.com> --- Changes in v3: - Leave the old defines in place (Conor, Palmer) Changes in v2: - Added patch to rename misaligned perf key values (Palmer) Documentation/arch/riscv/hwprobe.rst | 14 +++++++------- arch/riscv/include/uapi/asm/hwprobe.h | 5 +++++ arch/riscv/kernel/sys_hwprobe.c | 10 +++++----- arch/riscv/kernel/traps_misaligned.c | 6 +++--- arch/riscv/kernel/unaligned_access_speed.c | 12 ++++++------ 5 files changed, 26 insertions(+), 21 deletions(-) diff --git a/Documentation/arch/riscv/hwprobe.rst b/Documentation/arch/riscv/hwprobe.rst index 7121a00a8464..0d14e9d83a78 100644 --- a/Documentation/arch/riscv/hwprobe.rst +++ b/Documentation/arch/riscv/hwprobe.rst @@ -243,23 +243,23 @@ The following keys are defined: the performance of misaligned scalar native word accesses on the selected set of processors. - * :c:macro:`RISCV_HWPROBE_MISALIGNED_UNKNOWN`: The performance of misaligned - accesses is unknown. + * :c:macro:`RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN`: The performance of + misaligned accesses is unknown. - * :c:macro:`RISCV_HWPROBE_MISALIGNED_EMULATED`: Misaligned accesses are + * :c:macro:`RISCV_HWPROBE_MISALIGNED_SCALAR_EMULATED`: Misaligned accesses are emulated via software, either in or below the kernel. These accesses are always extremely slow. - * :c:macro:`RISCV_HWPROBE_MISALIGNED_SLOW`: Misaligned native word + * :c:macro:`RISCV_HWPROBE_MISALIGNED_SCALAR_SLOW`: Misaligned native word sized accesses are slower than the equivalent quantity of byte accesses. Misaligned accesses may be supported directly in hardware, or trapped and emulated by software. - * :c:macro:`RISCV_HWPROBE_MISALIGNED_FAST`: Misaligned native word + * :c:macro:`RISCV_HWPROBE_MISALIGNED_SCALAR_FAST`: Misaligned native word sized accesses are faster than the equivalent quantity of byte accesses. - * :c:macro:`RISCV_HWPROBE_MISALIGNED_UNSUPPORTED`: Misaligned accesses are - not supported at all and will generate a misaligned address fault. + * :c:macro:`RISCV_HWPROBE_MISALIGNED_SCALAR_UNSUPPORTED`: Misaligned accesses + are not supported at all and will generate a misaligned address fault. * :c:macro:`RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE`: An unsigned int which represents the size of the Zicboz block in bytes. diff --git a/arch/riscv/include/uapi/asm/hwprobe.h b/arch/riscv/include/uapi/asm/hwprobe.h index 7ebb2f2cc4cf..bcb2d91241d5 100644 --- a/arch/riscv/include/uapi/asm/hwprobe.h +++ b/arch/riscv/include/uapi/asm/hwprobe.h @@ -80,6 +80,11 @@ struct riscv_hwprobe { #define RISCV_HWPROBE_MISALIGNED_MASK (7 << 0) #define RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE 6 #define RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF 7 +#define RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN 0 +#define RISCV_HWPROBE_MISALIGNED_SCALAR_EMULATED 1 +#define RISCV_HWPROBE_MISALIGNED_SCALAR_SLOW 2 +#define RISCV_HWPROBE_MISALIGNED_SCALAR_FAST 3 +#define RISCV_HWPROBE_MISALIGNED_SCALAR_UNSUPPORTED 4 /* Increase RISCV_HWPROBE_MAX_KEY when adding items. */ /* Flags */ diff --git a/arch/riscv/kernel/sys_hwprobe.c b/arch/riscv/kernel/sys_hwprobe.c index b18639020c61..d5541f6c843e 100644 --- a/arch/riscv/kernel/sys_hwprobe.c +++ b/arch/riscv/kernel/sys_hwprobe.c @@ -176,13 +176,13 @@ static u64 hwprobe_misaligned(const struct cpumask *cpus) perf = this_perf; if (perf != this_perf) { - perf = RISCV_HWPROBE_MISALIGNED_UNKNOWN; + perf = RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN; break; } } if (perf == -1ULL) - return RISCV_HWPROBE_MISALIGNED_UNKNOWN; + return RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN; return perf; } @@ -190,12 +190,12 @@ static u64 hwprobe_misaligned(const struct cpumask *cpus) static u64 hwprobe_misaligned(const struct cpumask *cpus) { if (IS_ENABLED(CONFIG_RISCV_EFFICIENT_UNALIGNED_ACCESS)) - return RISCV_HWPROBE_MISALIGNED_FAST; + return RISCV_HWPROBE_MISALIGNED_SCALAR_FAST; if (IS_ENABLED(CONFIG_RISCV_EMULATED_UNALIGNED_ACCESS) && unaligned_ctl_available()) - return RISCV_HWPROBE_MISALIGNED_EMULATED; + return RISCV_HWPROBE_MISALIGNED_SCALAR_EMULATED; - return RISCV_HWPROBE_MISALIGNED_SLOW; + return RISCV_HWPROBE_MISALIGNED_SCALAR_SLOW; } #endif diff --git a/arch/riscv/kernel/traps_misaligned.c b/arch/riscv/kernel/traps_misaligned.c index b62d5a2f4541..192cd5603e95 100644 --- a/arch/riscv/kernel/traps_misaligned.c +++ b/arch/riscv/kernel/traps_misaligned.c @@ -338,7 +338,7 @@ int handle_misaligned_load(struct pt_regs *regs) perf_sw_event(PERF_COUNT_SW_ALIGNMENT_FAULTS, 1, regs, addr); #ifdef CONFIG_RISCV_PROBE_UNALIGNED_ACCESS - *this_cpu_ptr(&misaligned_access_speed) = RISCV_HWPROBE_MISALIGNED_EMULATED; + *this_cpu_ptr(&misaligned_access_speed) = RISCV_HWPROBE_MISALIGNED_SCALAR_EMULATED; #endif if (!unaligned_enabled) @@ -532,13 +532,13 @@ static bool check_unaligned_access_emulated(int cpu) unsigned long tmp_var, tmp_val; bool misaligned_emu_detected; - *mas_ptr = RISCV_HWPROBE_MISALIGNED_UNKNOWN; + *mas_ptr = RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN; __asm__ __volatile__ ( " "REG_L" %[tmp], 1(%[ptr])\n" : [tmp] "=r" (tmp_val) : [ptr] "r" (&tmp_var) : "memory"); - misaligned_emu_detected = (*mas_ptr == RISCV_HWPROBE_MISALIGNED_EMULATED); + misaligned_emu_detected = (*mas_ptr == RISCV_HWPROBE_MISALIGNED_SCALAR_EMULATED); /* * If unaligned_ctl is already set, this means that we detected that all * CPUS uses emulated misaligned access at boot time. If that changed diff --git a/arch/riscv/kernel/unaligned_access_speed.c b/arch/riscv/kernel/unaligned_access_speed.c index a9a6bcb02acf..160628a2116d 100644 --- a/arch/riscv/kernel/unaligned_access_speed.c +++ b/arch/riscv/kernel/unaligned_access_speed.c @@ -34,9 +34,9 @@ static int check_unaligned_access(void *param) struct page *page = param; void *dst; void *src; - long speed = RISCV_HWPROBE_MISALIGNED_SLOW; + long speed = RISCV_HWPROBE_MISALIGNED_SCALAR_SLOW; - if (per_cpu(misaligned_access_speed, cpu) != RISCV_HWPROBE_MISALIGNED_UNKNOWN) + if (per_cpu(misaligned_access_speed, cpu) != RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN) return 0; /* Make an unaligned destination buffer. */ @@ -95,14 +95,14 @@ static int check_unaligned_access(void *param) } if (word_cycles < byte_cycles) - speed = RISCV_HWPROBE_MISALIGNED_FAST; + speed = RISCV_HWPROBE_MISALIGNED_SCALAR_FAST; ratio = div_u64((byte_cycles * 100), word_cycles); pr_info("cpu%d: Ratio of byte access time to unaligned word access is %d.%02d, unaligned accesses are %s\n", cpu, ratio / 100, ratio % 100, - (speed == RISCV_HWPROBE_MISALIGNED_FAST) ? "fast" : "slow"); + (speed == RISCV_HWPROBE_MISALIGNED_SCALAR_FAST) ? "fast" : "slow"); per_cpu(misaligned_access_speed, cpu) = speed; @@ -110,7 +110,7 @@ static int check_unaligned_access(void *param) * Set the value of fast_misaligned_access of a CPU. These operations * are atomic to avoid race conditions. */ - if (speed == RISCV_HWPROBE_MISALIGNED_FAST) + if (speed == RISCV_HWPROBE_MISALIGNED_SCALAR_FAST) cpumask_set_cpu(cpu, &fast_misaligned_access); else cpumask_clear_cpu(cpu, &fast_misaligned_access); @@ -188,7 +188,7 @@ static int riscv_online_cpu(unsigned int cpu) static struct page *buf; /* We are already set since the last check */ - if (per_cpu(misaligned_access_speed, cpu) != RISCV_HWPROBE_MISALIGNED_UNKNOWN) + if (per_cpu(misaligned_access_speed, cpu) != RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN) goto exit; buf = alloc_pages(GFP_KERNEL, MISALIGNED_BUFFER_ORDER); -- 2.34.1 ^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [PATCH v3 2/2] RISC-V: hwprobe: Add SCALAR to misaligned perf defines 2024-06-27 17:22 ` [PATCH v3 2/2] RISC-V: hwprobe: Add SCALAR to misaligned perf defines Evan Green @ 2024-08-07 17:56 ` Charlie Jenkins 2024-08-09 21:45 ` Evan Green 0 siblings, 1 reply; 5+ messages in thread From: Charlie Jenkins @ 2024-08-07 17:56 UTC (permalink / raw) To: Evan Green Cc: Palmer Dabbelt, Yangyu Chen, Albert Ou, Alexandre Ghiti, Andrew Jones, Andy Chiu, Ben Dooks, Björn Töpel, Clément Léger, Conor Dooley, Costa Shulyupin, Erick Archer, Jonathan Corbet, Paul Walmsley, linux-doc, linux-kernel, linux-riscv On Thu, Jun 27, 2024 at 10:22:38AM -0700, Evan Green wrote: > In preparation for misaligned vector performance hwprobe keys, rename > the hwprobe key values associated with misaligned scalar accesses to > include the term SCALAR. Leave the old defines in place to maintain > source compatibility. > > This change is intended to be a functional no-op. > > Signed-off-by: Evan Green <evan@rivosinc.com> > Reviewed-by: Charlie Jenkins <charlie@rivosinc.com> > > --- > > Changes in v3: > - Leave the old defines in place (Conor, Palmer) > > Changes in v2: > - Added patch to rename misaligned perf key values (Palmer) > > Documentation/arch/riscv/hwprobe.rst | 14 +++++++------- > arch/riscv/include/uapi/asm/hwprobe.h | 5 +++++ > arch/riscv/kernel/sys_hwprobe.c | 10 +++++----- > arch/riscv/kernel/traps_misaligned.c | 6 +++--- > arch/riscv/kernel/unaligned_access_speed.c | 12 ++++++------ > 5 files changed, 26 insertions(+), 21 deletions(-) > > diff --git a/Documentation/arch/riscv/hwprobe.rst b/Documentation/arch/riscv/hwprobe.rst > index 7121a00a8464..0d14e9d83a78 100644 > --- a/Documentation/arch/riscv/hwprobe.rst > +++ b/Documentation/arch/riscv/hwprobe.rst > @@ -243,23 +243,23 @@ The following keys are defined: > the performance of misaligned scalar native word accesses on the selected set > of processors. > > - * :c:macro:`RISCV_HWPROBE_MISALIGNED_UNKNOWN`: The performance of misaligned > - accesses is unknown. > + * :c:macro:`RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN`: The performance of > + misaligned accesses is unknown. Hey Evan, This series hasn't landed yet, can you rebase and resend? There is a patch [1] that changes the wording of this description to "misaligned scalar" instead of "misaligned". Can you apply that wording change to these new keys? - Charlie Link: https://lore.kernel.org/linux-riscv/CAJgzZorn5anPH8dVPqvjVWmLKqTi5bkLDR=FH-ZAcdXFnNe8Eg@mail.gmail.com/ > > - * :c:macro:`RISCV_HWPROBE_MISALIGNED_EMULATED`: Misaligned accesses are > + * :c:macro:`RISCV_HWPROBE_MISALIGNED_SCALAR_EMULATED`: Misaligned accesses are > emulated via software, either in or below the kernel. These accesses are > always extremely slow. > > - * :c:macro:`RISCV_HWPROBE_MISALIGNED_SLOW`: Misaligned native word > + * :c:macro:`RISCV_HWPROBE_MISALIGNED_SCALAR_SLOW`: Misaligned native word > sized accesses are slower than the equivalent quantity of byte accesses. > Misaligned accesses may be supported directly in hardware, or trapped and > emulated by software. > > - * :c:macro:`RISCV_HWPROBE_MISALIGNED_FAST`: Misaligned native word > + * :c:macro:`RISCV_HWPROBE_MISALIGNED_SCALAR_FAST`: Misaligned native word > sized accesses are faster than the equivalent quantity of byte accesses. > > - * :c:macro:`RISCV_HWPROBE_MISALIGNED_UNSUPPORTED`: Misaligned accesses are > - not supported at all and will generate a misaligned address fault. > + * :c:macro:`RISCV_HWPROBE_MISALIGNED_SCALAR_UNSUPPORTED`: Misaligned accesses > + are not supported at all and will generate a misaligned address fault. > > * :c:macro:`RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE`: An unsigned int which > represents the size of the Zicboz block in bytes. > diff --git a/arch/riscv/include/uapi/asm/hwprobe.h b/arch/riscv/include/uapi/asm/hwprobe.h > index 7ebb2f2cc4cf..bcb2d91241d5 100644 > --- a/arch/riscv/include/uapi/asm/hwprobe.h > +++ b/arch/riscv/include/uapi/asm/hwprobe.h > @@ -80,6 +80,11 @@ struct riscv_hwprobe { > #define RISCV_HWPROBE_MISALIGNED_MASK (7 << 0) > #define RISCV_HWPROBE_KEY_ZICBOZ_BLOCK_SIZE 6 > #define RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF 7 > +#define RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN 0 > +#define RISCV_HWPROBE_MISALIGNED_SCALAR_EMULATED 1 > +#define RISCV_HWPROBE_MISALIGNED_SCALAR_SLOW 2 > +#define RISCV_HWPROBE_MISALIGNED_SCALAR_FAST 3 > +#define RISCV_HWPROBE_MISALIGNED_SCALAR_UNSUPPORTED 4 > /* Increase RISCV_HWPROBE_MAX_KEY when adding items. */ > > /* Flags */ > diff --git a/arch/riscv/kernel/sys_hwprobe.c b/arch/riscv/kernel/sys_hwprobe.c > index b18639020c61..d5541f6c843e 100644 > --- a/arch/riscv/kernel/sys_hwprobe.c > +++ b/arch/riscv/kernel/sys_hwprobe.c > @@ -176,13 +176,13 @@ static u64 hwprobe_misaligned(const struct cpumask *cpus) > perf = this_perf; > > if (perf != this_perf) { > - perf = RISCV_HWPROBE_MISALIGNED_UNKNOWN; > + perf = RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN; > break; > } > } > > if (perf == -1ULL) > - return RISCV_HWPROBE_MISALIGNED_UNKNOWN; > + return RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN; > > return perf; > } > @@ -190,12 +190,12 @@ static u64 hwprobe_misaligned(const struct cpumask *cpus) > static u64 hwprobe_misaligned(const struct cpumask *cpus) > { > if (IS_ENABLED(CONFIG_RISCV_EFFICIENT_UNALIGNED_ACCESS)) > - return RISCV_HWPROBE_MISALIGNED_FAST; > + return RISCV_HWPROBE_MISALIGNED_SCALAR_FAST; > > if (IS_ENABLED(CONFIG_RISCV_EMULATED_UNALIGNED_ACCESS) && unaligned_ctl_available()) > - return RISCV_HWPROBE_MISALIGNED_EMULATED; > + return RISCV_HWPROBE_MISALIGNED_SCALAR_EMULATED; > > - return RISCV_HWPROBE_MISALIGNED_SLOW; > + return RISCV_HWPROBE_MISALIGNED_SCALAR_SLOW; > } > #endif > > diff --git a/arch/riscv/kernel/traps_misaligned.c b/arch/riscv/kernel/traps_misaligned.c > index b62d5a2f4541..192cd5603e95 100644 > --- a/arch/riscv/kernel/traps_misaligned.c > +++ b/arch/riscv/kernel/traps_misaligned.c > @@ -338,7 +338,7 @@ int handle_misaligned_load(struct pt_regs *regs) > perf_sw_event(PERF_COUNT_SW_ALIGNMENT_FAULTS, 1, regs, addr); > > #ifdef CONFIG_RISCV_PROBE_UNALIGNED_ACCESS > - *this_cpu_ptr(&misaligned_access_speed) = RISCV_HWPROBE_MISALIGNED_EMULATED; > + *this_cpu_ptr(&misaligned_access_speed) = RISCV_HWPROBE_MISALIGNED_SCALAR_EMULATED; > #endif > > if (!unaligned_enabled) > @@ -532,13 +532,13 @@ static bool check_unaligned_access_emulated(int cpu) > unsigned long tmp_var, tmp_val; > bool misaligned_emu_detected; > > - *mas_ptr = RISCV_HWPROBE_MISALIGNED_UNKNOWN; > + *mas_ptr = RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN; > > __asm__ __volatile__ ( > " "REG_L" %[tmp], 1(%[ptr])\n" > : [tmp] "=r" (tmp_val) : [ptr] "r" (&tmp_var) : "memory"); > > - misaligned_emu_detected = (*mas_ptr == RISCV_HWPROBE_MISALIGNED_EMULATED); > + misaligned_emu_detected = (*mas_ptr == RISCV_HWPROBE_MISALIGNED_SCALAR_EMULATED); > /* > * If unaligned_ctl is already set, this means that we detected that all > * CPUS uses emulated misaligned access at boot time. If that changed > diff --git a/arch/riscv/kernel/unaligned_access_speed.c b/arch/riscv/kernel/unaligned_access_speed.c > index a9a6bcb02acf..160628a2116d 100644 > --- a/arch/riscv/kernel/unaligned_access_speed.c > +++ b/arch/riscv/kernel/unaligned_access_speed.c > @@ -34,9 +34,9 @@ static int check_unaligned_access(void *param) > struct page *page = param; > void *dst; > void *src; > - long speed = RISCV_HWPROBE_MISALIGNED_SLOW; > + long speed = RISCV_HWPROBE_MISALIGNED_SCALAR_SLOW; > > - if (per_cpu(misaligned_access_speed, cpu) != RISCV_HWPROBE_MISALIGNED_UNKNOWN) > + if (per_cpu(misaligned_access_speed, cpu) != RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN) > return 0; > > /* Make an unaligned destination buffer. */ > @@ -95,14 +95,14 @@ static int check_unaligned_access(void *param) > } > > if (word_cycles < byte_cycles) > - speed = RISCV_HWPROBE_MISALIGNED_FAST; > + speed = RISCV_HWPROBE_MISALIGNED_SCALAR_FAST; > > ratio = div_u64((byte_cycles * 100), word_cycles); > pr_info("cpu%d: Ratio of byte access time to unaligned word access is %d.%02d, unaligned accesses are %s\n", > cpu, > ratio / 100, > ratio % 100, > - (speed == RISCV_HWPROBE_MISALIGNED_FAST) ? "fast" : "slow"); > + (speed == RISCV_HWPROBE_MISALIGNED_SCALAR_FAST) ? "fast" : "slow"); > > per_cpu(misaligned_access_speed, cpu) = speed; > > @@ -110,7 +110,7 @@ static int check_unaligned_access(void *param) > * Set the value of fast_misaligned_access of a CPU. These operations > * are atomic to avoid race conditions. > */ > - if (speed == RISCV_HWPROBE_MISALIGNED_FAST) > + if (speed == RISCV_HWPROBE_MISALIGNED_SCALAR_FAST) > cpumask_set_cpu(cpu, &fast_misaligned_access); > else > cpumask_clear_cpu(cpu, &fast_misaligned_access); > @@ -188,7 +188,7 @@ static int riscv_online_cpu(unsigned int cpu) > static struct page *buf; > > /* We are already set since the last check */ > - if (per_cpu(misaligned_access_speed, cpu) != RISCV_HWPROBE_MISALIGNED_UNKNOWN) > + if (per_cpu(misaligned_access_speed, cpu) != RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN) > goto exit; > > buf = alloc_pages(GFP_KERNEL, MISALIGNED_BUFFER_ORDER); > -- > 2.34.1 > ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH v3 2/2] RISC-V: hwprobe: Add SCALAR to misaligned perf defines 2024-08-07 17:56 ` Charlie Jenkins @ 2024-08-09 21:45 ` Evan Green 0 siblings, 0 replies; 5+ messages in thread From: Evan Green @ 2024-08-09 21:45 UTC (permalink / raw) To: Charlie Jenkins Cc: Palmer Dabbelt, Yangyu Chen, Albert Ou, Alexandre Ghiti, Andrew Jones, Andy Chiu, Ben Dooks, Björn Töpel, Clément Léger, Conor Dooley, Costa Shulyupin, Erick Archer, Jonathan Corbet, Paul Walmsley, linux-doc, linux-kernel, linux-riscv On Wed, Aug 7, 2024 at 10:56 AM Charlie Jenkins <charlie@rivosinc.com> wrote: > > On Thu, Jun 27, 2024 at 10:22:38AM -0700, Evan Green wrote: > > In preparation for misaligned vector performance hwprobe keys, rename > > the hwprobe key values associated with misaligned scalar accesses to > > include the term SCALAR. Leave the old defines in place to maintain > > source compatibility. > > > > This change is intended to be a functional no-op. > > > > Signed-off-by: Evan Green <evan@rivosinc.com> > > Reviewed-by: Charlie Jenkins <charlie@rivosinc.com> > > > > --- > > > > Changes in v3: > > - Leave the old defines in place (Conor, Palmer) > > > > Changes in v2: > > - Added patch to rename misaligned perf key values (Palmer) > > > > Documentation/arch/riscv/hwprobe.rst | 14 +++++++------- > > arch/riscv/include/uapi/asm/hwprobe.h | 5 +++++ > > arch/riscv/kernel/sys_hwprobe.c | 10 +++++----- > > arch/riscv/kernel/traps_misaligned.c | 6 +++--- > > arch/riscv/kernel/unaligned_access_speed.c | 12 ++++++------ > > 5 files changed, 26 insertions(+), 21 deletions(-) > > > > diff --git a/Documentation/arch/riscv/hwprobe.rst b/Documentation/arch/riscv/hwprobe.rst > > index 7121a00a8464..0d14e9d83a78 100644 > > --- a/Documentation/arch/riscv/hwprobe.rst > > +++ b/Documentation/arch/riscv/hwprobe.rst > > @@ -243,23 +243,23 @@ The following keys are defined: > > the performance of misaligned scalar native word accesses on the selected set > > of processors. > > > > - * :c:macro:`RISCV_HWPROBE_MISALIGNED_UNKNOWN`: The performance of misaligned > > - accesses is unknown. > > + * :c:macro:`RISCV_HWPROBE_MISALIGNED_SCALAR_UNKNOWN`: The performance of > > + misaligned accesses is unknown. > > Hey Evan, > > This series hasn't landed yet, can you rebase and resend? There is a > patch [1] that changes the wording of this description to "misaligned > scalar" instead of "misaligned". Can you apply that wording change to > these new keys? Done. ^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2024-08-09 21:46 UTC | newest] Thread overview: 5+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2024-06-27 17:22 [PATCH v3 0/2] RISC-V: hwprobe: Misaligned scalar perf fix and rename Evan Green 2024-06-27 17:22 ` [PATCH v3 1/2] RISC-V: hwprobe: Add MISALIGNED_PERF key Evan Green 2024-06-27 17:22 ` [PATCH v3 2/2] RISC-V: hwprobe: Add SCALAR to misaligned perf defines Evan Green 2024-08-07 17:56 ` Charlie Jenkins 2024-08-09 21:45 ` Evan Green
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).