[libc] Check pointer equality in strcmp, strncmp, and memcmp

[squidgyberries]

Summary

Check if left and right point to the same location before looping through the bytes.

[michaelrj]

This patch looks fine codewise, but do you have any numbers on what the performance impact will be for strings that are not pointer-equal?

[squidgyberries]

#include "include/string.h"

int main(void) {
  for (unsigned long i = 0; i < 50000000000; ++i) strcmp("hello", "world");
  return 0;
}

I compiled this with clang 15.0.7 on my x64 Arch Linux machine with an Intel i7-12700H without optimizations. I ran it five times with the patch and five time without it and timed it with the time command. On average it ran for 12.8618 seconds with the patch and 12.8766 seconds without for me.

[gchatelet]

I suspect it is almost never the case that we call these functions with the same pointer on both sides.
In my opinion, this optimization is best done at the call site when the user suspects that it can actually happen.

For memfunction, we want to reduce the function's latency to a minimum so the check being in the hot path actually hinders performance.

So, codewise this patch is fine but I don't think we should submit it.

libc/src/string/memory_utils/memcmp_implementations.h

 #include "src/string/memory_utils/op_x86.h"
 #include "src/string/memory_utils/utils.h"
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 [[maybe_unused]] LIBC_INLINE MemcmpReturnType
 inline_memcmp_embedded_tiny(CPtr p1, CPtr p2, size_t count) {
+  if (p1 == p2)
+    return MemcmpReturnType::ZERO();
+
   LLVM_LIBC_LOOP_NOUNROLL
   for (size_t offset = 0; offset < count; ++offset)
     if (auto value = generic::Memcmp<1>::block(p1 + offset, p2 + offset))
       return value;
   return MemcmpReturnType::ZERO();
 }
 
 #if defined(LLVM_LIBC_ARCH_X86) || defined(LLVM_LIBC_ARCH_AARCH64)

libc/src/string/memory_utils/strcmp_implementations.h

 
 #include <stddef.h>
 
 namespace __llvm_libc {
 
 template <typename Comp>
 constexpr static int strcmp_implementation(const char *left, const char *right,
                                            Comp &&comp) {
+  if (left == right)
+    return 0;
+
   // TODO: Look at benefits for comparing words at a time.
   for (; *left && !comp(*left, *right); ++left, ++right)
     ;
   return comp(*reinterpret_cast<const unsigned char *>(left),
               *reinterpret_cast<const unsigned char *>(right));
 }
 
 template <typename Comp>
 constexpr static int strncmp_implementation(const char *left, const char *right,
                                             size_t n, Comp &&comp) {
   if (n == 0)
     return 0;
 
+  if (left == right)
+    return 0;
+
   // TODO: Look at benefits for comparing words at a time.
   for (; n > 1; --n, ++left, ++right) {
     char lc = *left;
     if (!comp(lc, '\0') || comp(lc, *right))
       break;
   }
   return comp(*reinterpret_cast<const unsigned char *>(left),
               *reinterpret_cast<const unsigned char *>(right));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_STRCMP_IMPLEMENTATIONS_H