riscv: lib: add memcmp() implementation
Subsystems (2)
PATCH 1/2 riscv: lib: add memcmp() implementation
From: Milan Tripkovic <[email protected]>
Add an assembly implementation of memcmp() for RISC-V. The implementation uses the ZBB extension for word-at-a-time comparison and an assembly fallback for non-ZBB systems.
Benchmark results (QEMU TCG, rv64):
Len | Def | NoZBB | ZBB | %NoZBB | %ZBB -----|-------|-------|-------|--------|------- 1 B | 22.4 | 24.6 | 23.2 | +9.8% | +3.5% 7 B | 96.9 | 108.5 | 107.3 | +12.0% | +10.7% 8 B | 107.0 | 116.3 | 176.7 | +8.7% | +65.1% 16 B | 148.4 | 172.8 | 315.6 | +16.4% | +112.6% 31 B | 182.2 | 217.1 | 377.6 | +19.2% | +107.2% 64 B | 220.6 | 239.4 | 874.2 | +8.5% | +296.2% 127 B| 213.7 | 254.8 | 1042.9| +19.2% | +388.0% 512 B| 255.1 | 269.0 | 1778.6| +5.4% | +597.2% 1024B| 252.3 | 280.9 | 1887.7| +11.3% | +648.1% 3173B| 241.3 | 288.7 | 2063.2| +19.6% | +755.0% 4096B| 240.9 | 280.5 | 2064.5| +16.4% | +756.9%
--- arch/riscv/include/asm/string.h | 2 + arch/riscv/lib/Makefile | 1 + arch/riscv/lib/memcmp.S | 103 ++++++++++++++++++++++++++++++++ arch/riscv/purgatory/Makefile | 5 +- 4 files changed, 110 insertions(+), 1 deletion(-) create mode 100644 arch/riscv/lib/memcmp.S
arch/riscv/include/asm/string.h +2 -0
@@ -18,6 +18,8 @@ extern asmlinkage void *__memcpy(void *, const void *, size_t);#define __HAVE_ARCH_MEMMOVE extern asmlinkage void *memmove(void *, const void *, size_t); extern asmlinkage void *__memmove(void *, const void *, size_t); +#define __HAVE_ARCH_MEMCMP +extern asmlinkage int memcmp(const void *, const void *, size_t);#if !(defined(CONFIG_KASAN_GENERIC ) || defined(CONFIG_KASAN_SW_TAGS ))#define __HAVE_ARCH_STRCMP
arch/riscv/lib/Makefile +1 -0
@@ -3,6 +3,7 @@ lib-y += delay.o lib-y += memcpy.o lib-y += memset.o lib-y += memmove.o +lib-y += memcmp.o ifeq ($(CONFIG_KASAN_GENERIC)$(CONFIG_KASAN_SW_TAGS),) lib-y += strcmp.o lib-y += strlen.o
arch/riscv/lib/memcmp.S new file +103 -0
103 lines not on this page · raw message
arch/riscv/purgatory/Makefile +4 -1
@@ -1,6 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 -purgatory-y := purgatory.o sha256.o entry.o string.o ctype.o memcpy.o memset.o +purgatory-y := purgatory.o sha256.o entry.o string.o ctype.o memcpy.o memset.o memcmp.o ifeq ($(CONFIG_KASAN_GENERIC)$(CONFIG_KASAN_SW_TAGS),) purgatory-y += strcmp.o strlen.o strncmp.o strnlen.o strchr.o strrchr.o endif
@@ -41,6 +41,9 @@ $(obj)/strchr.o: $(srctree)/arch/riscv/lib/strchr.S FORCE $(obj)/strrchr.o: $(srctree)/arch/riscv/lib/strrchr.S FORCE $(call if_changed_rule,as_o_S) +$(obj)/memcmp.o: $(srctree)/arch/riscv/lib/memcmp.S FORCE + $(call if_changed_rule,as_o_S) + CFLAGS_sha256.o := -D__DISABLE_EXPORTS -D__NO_FORTIFY CFLAGS_string.o := -D__DISABLE_EXPORTS CFLAGS_ctype.o := -D__DISABLE_EXPORTS
Signature · 1 line
2.43.0
PATCH 2/2 lib/string_kunit: extend benchmarks and unit test to memcmp()
From: Milan Tripkovic <[email protected]>
Extend the string benchmarking suite to include memcmp(). Extend the string unit test to include memcmp().
--- lib/tests/string_kunit.c | 102 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 102 insertions(+)
lib/tests/string_kunit.c +102 -0
@@ -880,6 +880,106 @@ static void string_bench_strrchr(struct kunit *test) {STRING_BENCH_BUF (test, buf, len, strrchr, buf,'\0' ); } +static void string_test_memcmp (struct kunit *test) +{ +const int max_offset =16 ; +const int max_len =32 ; +const int buf_size = max_offset + max_len +32 ; +u8 *buf1, *buf2; +int i, j, len, k; + + buf1 =kunit_kzalloc (test, buf_size,GFP_KERNEL ); + buf2 =kunit_kzalloc (test, buf_size,GFP_KERNEL ); +KUNIT_ASSERT_NOT_ERR_OR_NULL (test, buf1); +KUNIT_ASSERT_NOT_ERR_OR_NULL (test, buf2); + +for (i =0 ; i < max_offset; i++) { +for (j =0 ; j < max_offset; j++) { +for (len =0 ; len <= max_len; len++) { +memset (buf1,'A' , buf_size); +memset (buf2,'A' , buf_size); +KUNIT_EXPECT_EQ_MSG (test,memcmp (buf1 + i, buf2 + j, len),0 , +"Should be equal: i:%d j:%d len:%d" , i, j, len); +for (k =0 ; k < len; k++) { +memset (buf1,'A' , buf_size); +memset (buf2,'A' , buf_size); + buf2[j + k] ='B' ; +int res =memcmp (buf1 + i, buf2 + j, len); + +KUNIT_EXPECT_NE_MSG (test, res,0 , +"Should detect difference at k:%d (i:%d j:%d len:%d)" , + k, i, j, len); + +if (buf1[i + k] < buf2[j + k]) +KUNIT_EXPECT_LT (test, res,0 ); +else +KUNIT_EXPECT_GT (test, res,0 ); + } + } + } + } +} +#if IS_ENABLED (CONFIG_STRING_KUNIT_BENCH ) +static void string_bench_memcmp (struct kunit *test) +{ +char *buf1, *buf2; +size_t lengths[] = {1 ,7 ,8 ,16 ,32 ,64 ,128 ,512 ,1024 ,4096 }; +int offsets[] = {0 ,1 ,3 ,7 }; +const size_t max_len =4096 +64 ; +int res =0 ; + + buf1 =vmalloc (max_len); + buf2 =vmalloc (max_len); + +if (!buf1 || !buf2) { +vfree (buf1); +vfree (buf2); +kunit_err (test,"vmalloc failed\n" ); +return ; + } + +memset (buf1,'A' , max_len); +memset (buf2,'A' , max_len); + +for (int i =0 ; i <100000 ; i++) + res +=memcmp (buf1, buf2,4096 ); + +for (int o =0 ; o <ARRAY_SIZE (offsets); o++) { +int off = offsets[o]; + +for (int i =0 ; i <ARRAY_SIZE (lengths); i++) { +size_t len = lengths[i]; +char *p1 = buf1; +char *p2 = buf2 + off; + +u32 iterations = (len <512 ) ?100000 :10000 ; + +for (u32 j =0 ; j < iterations; j++) { + asmvolatile ("" : :"g" (p1),"g" (p2),"g" (len) :"memory" ); +int res =memcmp (p1, p2, len); + + asmvolatile ("" : :"g" (res) :"memory" ); + } + +u64 elapsed =STRING_BENCH (iterations, memcmp, p1, p2, len); +u64 ns_per_call =div_u64 (elapsed, iterations); +u64 mbps = len ?div_u64 ((u64 )len * iterations *1000 , + elapsed) :0 ; + +if (off ==0 ) { +kunit_info (test,"bench_memcmp_aligned: len=%-4zu: %llu MB/s (%llu ns/call)\n" , + len, mbps, ns_per_call); + }else { +kunit_info (test,"bench_memcmp_unaligned(off=%d): len=%-4zu: %llu MB/s (%llu ns/call)\n" , + off, len, mbps, ns_per_call); + } + } + } + +vfree (buf1); +vfree (buf2); +} +#endif static struct kunit_case string_test_cases[] = {KUNIT_CASE (string_test_memset16),
@@ -910,6 +1010,8 @@ static struct kunit_case string_test_cases[] = {KUNIT_CASE (string_bench_strnlen),KUNIT_CASE (string_bench_strchr),KUNIT_CASE (string_bench_strrchr), +KUNIT_CASE (string_test_memcmp), + KUNIT_CASE_SLOW(string_bench_memcmp), {} };
Signature · 1 line
2.43.0
Quoted 109 lines · On Tue, 12 May 2026 16:10:06 +0200 Milan Tripkovic <[email protected]> wrote:
From: Milan Tripkovic <[email protected]>
Add an assembly implementation of
memcmp()for RISC-V. The implementation uses the ZBB extension for word-at-a-time comparison and an assembly fallback for non-ZBB systems.Benchmark results (QEMU TCG, rv64):
Len | Def | NoZBB | ZBB | %NoZBB | %ZBB -----|-------|-------|-------|--------|------- 1 B | 22.4 | 24.6 | 23.2 | +9.8% | +3.5% 7 B | 96.9 | 108.5 | 107.3 | +12.0% | +10.7% 8 B | 107.0 | 116.3 | 176.7 | +8.7% | +65.1% 16 B | 148.4 | 172.8 | 315.6 | +16.4% | +112.6% 31 B | 182.2 | 217.1 | 377.6 | +19.2% | +107.2% 64 B | 220.6 | 239.4 | 874.2 | +8.5% | +296.2% 127 B| 213.7 | 254.8 | 1042.9| +19.2% | +388.0% 512 B| 255.1 | 269.0 | 1778.6| +5.4% | +597.2% 1024B| 252.3 | 280.9 | 1887.7| +11.3% | +648.1% 3173B| 241.3 | 288.7 | 2063.2| +19.6% | +755.0% 4096B| 240.9 | 280.5 | 2064.5| +16.4% | +756.9%Signed-off-by Milan Tripkovic <[email protected]>--- arch/riscv/include/asm/string.h | 2 + arch/riscv/lib/Makefile | 1 + arch/riscv/lib/memcmp.S | 103 ++++++++++++++++++++++++++++++++ arch/riscv/purgatory/Makefile | 5 +- 4 files changed, 110 insertions(+), 1 deletion(-) create mode 100644 arch/riscv/lib/memcmp.Sarch/riscv/include/asm/string.h +2
-0@@ -18,6 +18,8 @@ extern asmlinkage void *__memcpy(void *, const void *, size_t);#define __HAVE_ARCH_MEMMOVE extern asmlinkage void *memmove(void *, const void *, size_t); extern asmlinkage void *__memmove(void *, const void *, size_t); +#define __HAVE_ARCH_MEMCMP +extern asmlinkage int memcmp(const void *, const void *, size_t);#if !(defined(CONFIG_KASAN_GENERIC ) || defined(CONFIG_KASAN_SW_TAGS ))#define __HAVE_ARCH_STRCMParch/riscv/lib/Makefile +1
-0@@ -3,6 +3,7 @@ lib-y += delay.o lib-y += memcpy.o lib-y += memset.o lib-y += memmove.o +lib-y += memcmp.o ifeq ($(CONFIG_KASAN_GENERIC)$(CONFIG_KASAN_SW_TAGS),) lib-y += strcmp.o lib-y += strlen.oarch/riscv/lib/memcmp.S new file +47
-0@@ -0,0 +1,103 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +#include <linux/linkage.h> +#include <asm/asm.h> +#include <asm/alternative-macros.h> +#include <asm/hwcap.h> + +/* int memcmp(const void *cs, const void *ct, size_t n) */ +SYM_FUNC_START(memcmp) + + __ALTERNATIVE_CFG("nop", "j memcmp_zbb", 0, RISCV_ISA_EXT_ZBB, + IS_ENABLED(CONFIG_RISCV_ISA_ZBB) && IS_ENABLED(CONFIG_TOOLCHAIN_HAS_ZBB)) +/* + * Parameters + * a0 - Pointer to first memory block (cs), also return value + * a1 - Pointer to second memory block (ct) + * a2 - Number of bytes to compare (n), transformed to end pointer (a0 + n) + * + * Returns + * a0 - 0 if equal, positive if cs > ct, negative if cs < ct + * + * Clobbers + * t0, t1 + */ + beqz a2, 2f + add a2, a0, a2 +1: + lbu t0, 0(a0) + lbu t1, 0(a1) + bne t0, t1, 3f + addi a0, a0, 1 + addi a1, a1, 1 + bne a0, a2, 1b +2: + li a0, 0 + ret +3: + sub a0, t0, t1 + ret + + +memcmp_zbb: +.option push +.option arch,+zbb +/* + * Parameters + * a0 - Pointer to first memory block (cs), also return value
arch/riscv/lib/memcmp.S line 57
Quoted 10 lines
arch/riscv/lib/memcmp.S new file +10
-0+ * a1 - Pointer to second memory block (ct) + * a2 - Number of bytes to compare (n), decremented during loop + * + * Returns + * a0 - 0 if equal, positive if cs > ct, negative if cs < ct + * + * Clobbers + * t0, t1, t2 + */ + beq a0, a1, 4f
There is no point optimising for equal pointers.
arch/riscv/lib/memcmp.S line 64
Quoted 7 lines
arch/riscv/lib/memcmp.S new file +7
-0+ + li t0, SZREG + bltu a2, t0, 5f + +1: + REG_L t1, 0(a0) + REG_L t2, 0(a1)
Aren't there some systems where misaligned reads are very expensive? You might want to fall back to byte compares for misaligned buffers.
arch/riscv/lib/memcmp.S line 70
Quoted 6 lines
arch/riscv/lib/memcmp.S new file +6
-0+ bne t1, t2, 2f + + addi a0, a0, SZREG + addi a1, a1, SZREG + addi a2, a2, -SZREG + bgeu a2, t0, 1b
You've a loop with two comparisons it in.
Move the length one to the top and the check before the loop shouldn't be needed.
If you calculate the end address of one of the buffers you only need two increments in the loop, not three.
You might need to access -SZREG(a0) to get the data.
arch/riscv/lib/memcmp.S line 73
Quoted 3 lines
arch/riscv/lib/memcmp.S new file +3
-0+ +5: + beqz a2, 4f
If a0 and a1 are aligned you can read the next full word, shift right (LE, left BE) and then compare.
Quoted 6 lines
arch/riscv/lib/memcmp.S new file +6
-0+6: + lbu t1, 0(a0) + lbu t2, 0(a1) + bne t1, t2, 3f + addi a0, a0, 1 + addi a1, a1, 1
arch/riscv/lib/memcmp.S line 89
Quoted 10 lines
arch/riscv/lib/memcmp.S new file +10
-0+ addi a2, a2, -1 + bnez a2, 6b + +4: li a0, 0 + ret +2: +#ifndef CONFIG_CPU_BIG_ENDIAN + rev8 t1, t1 + rev8 t2, t2 +#endif
That looks like the only bit that needs zbb?
Is BIG_ENDIAN common enough to actually worry about?
You could just fall back to byte accesses (rereading memory) on BE.
-- David
Quoted 36 lines
arch/riscv/lib/memcmp.S new file +14
-0+ sltu a0, t2, t1 + sltu t0, t1, t2 + sub a0, a0, t0 + ret + +3: + sub a0, t1, t2 + ret + +.option pop + +SYM_FUNC_END(memcmp) +SYM_FUNC_ALIAS(__pi_memcmp, memcmp) +EXPORT_SYMBOL(memcmp)arch/riscv/purgatory/Makefile +4
-1@@ -1,6 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 -purgatory-y := purgatory.o sha256.o entry.o string.o ctype.o memcpy.o memset.o +purgatory-y := purgatory.o sha256.o entry.o string.o ctype.o memcpy.o memset.o memcmp.o ifeq ($(CONFIG_KASAN_GENERIC)$(CONFIG_KASAN_SW_TAGS),) purgatory-y += strcmp.o strlen.o strncmp.o strnlen.o strchr.o strrchr.o endif@@ -41,6 +41,9 @@ $(obj)/strchr.o: $(srctree)/arch/riscv/lib/strchr.S FORCE $(obj)/strrchr.o: $(srctree)/arch/riscv/lib/strrchr.S FORCE $(call if_changed_rule,as_o_S) +$(obj)/memcmp.o: $(srctree)/arch/riscv/lib/memcmp.S FORCE + $(call if_changed_rule,as_o_S) + CFLAGS_sha256.o := -D__DISABLE_EXPORTS -D__NO_FORTIFY CFLAGS_string.o := -D__DISABLE_EXPORTS CFLAGS_ctype.o := -D__DISABLE_EXPORTS