Add a fast memcpy() using MMX when we're moving >= 1KB.

This is a nice speedup for WindowServer. I'll eventually have to do this
with SSE but the kernel doesn't support SSE yet so this is it for now.

AK/StdLibExtras.cpp

@@ -0,0 +1,50 @@
+#include <AK/StdLibExtras.h>
+#include <AK/Assertions.h>
+#include <AK/Types.h>
+#include <AK/kstdio.h>
+
+void* mmx_memcpy(void* dest, const void* src, size_t len)
+{
+ ASSERT(len >= 1024);
+
+ auto* dest_ptr = (byte*)dest;
+ auto* src_ptr = (const byte*)src;
+
+ if ((dword)dest_ptr & 7) {
+ dword prologue = 8 - ((dword)dest_ptr & 7);
+ asm volatile(
+ "rep movsb\n"
+ :: "S"(src_ptr), "D"(dest_ptr), "c"(prologue)
+ : "memory"
+ );
+ len -= prologue;
+ }
+ for (dword i = len / 64; i; --i) {
+ asm volatile(
+ "movq (%0), %%mm0\n"
+ "movq 8(%0), %%mm1\n"
+ "movq 16(%0), %%mm2\n"
+ "movq 24(%0), %%mm3\n"
+ "movq 32(%0), %%mm4\n"
+ "movq 40(%0), %%mm5\n"
+ "movq 48(%0), %%mm6\n"
+ "movq 56(%0), %%mm7\n"
+ "movq %%mm0, (%1)\n"
+ "movq %%mm1, 8(%1)\n"
+ "movq %%mm2, 16(%1)\n"
+ "movq %%mm3, 24(%1)\n"
+ "movq %%mm4, 32(%1)\n"
+ "movq %%mm5, 40(%1)\n"
+ "movq %%mm6, 48(%1)\n"
+ "movq %%mm7, 56(%1)\n"
+ :: "r" (src_ptr), "r" (dest_ptr) : "memory");
+ src_ptr += 64;
+ dest_ptr += 64;
+ }
+ asm volatile("emms":::"memory");
+ // Whatever remains we'll have to memcpy.
+ len %= 64;
+ if (len)
+ memcpy(dest_ptr, src_ptr, len);
+ return dest;
+}

AK/StdLibExtras.h

@@ -9,8 +9,14 @@
 
 #include <AK/Types.h>
 
+void* mmx_memcpy(void* to, const void* from, size_t);
+
 ALWAYS_INLINE void fast_dword_copy(dword* dest, const dword* src, size_t count)
 {
+ if (count >= 256) {
+ mmx_memcpy(dest, src, count * sizeof(count));
+ return;
+ }
  asm volatile(
  "rep movsl\n"
  : "=S"(src), "=D"(dest), "=c"(count)

Kernel/Makefile

@@ -69,7 +69,8 @@ AK_OBJS = \
  ../AK/String.o \
  ../AK/StringImpl.o \
  ../AK/StringBuilder.o \
- ../AK/FileSystemPath.o
+ ../AK/FileSystemPath.o \
+ ../AK/StdLibExtras.o
 
 OBJS = $(KERNEL_OBJS) $(VFS_OBJS) $(AK_OBJS) $(WINDOWSERVER_OBJS) $(SHAREDGRAPHICS_OBJS)
 

Kernel/StdLib.cpp

@@ -1,12 +1,18 @@
 #include "types.h"
 #include "Assertions.h"
 #include "kmalloc.h"
+#include <AK/StdLibExtras.h>
 #include <AK/Types.h>
 
 extern "C" {
 
-void memcpy(void *dest_ptr, const void *src_ptr, dword n)
+void memcpy(void* dest_ptr, const void* src_ptr, dword n)
 {
+ if (n >= 1024) {
+ mmx_memcpy(dest_ptr, src_ptr, n);
+ return;
+ }
+
  dword dest = (dword)dest_ptr;
  dword src = (dword)src_ptr;
  // FIXME: Support starting at an unaligned address.

LibC/Makefile

@@ -3,6 +3,7 @@ AK_OBJS = \
  ../AK/String.o \
  ../AK/StringBuilder.o \
  ../AK/FileSystemPath.o \
+ ../AK/StdLibExtras.o \
  ../AK/kmalloc.o
 
 SHAREDGRAPHICS_OBJS = \

LibC/string.cpp

@@ -102,8 +102,11 @@ int memcmp(const void* v1, const void* v2, size_t n)
  return 0;
 }
 
-void* memcpy(void *dest_ptr, const void *src_ptr, dword n)
+void* memcpy(void* dest_ptr, const void* src_ptr, dword n)
 {
+ if (n >= 1024)
+ return mmx_memcpy(dest_ptr, src_ptr, n);
+
  dword dest = (dword)dest_ptr;
  dword src = (dword)src_ptr;
  // FIXME: Support starting at an unaligned address.