Kernel: Use word-sized writes in the generic memset implementation

This decreases the boot time on my x86-64 host system from 15 s to 13 s
for AArch64 QEMU TCG and 33 s to 30 s for RISC-V QEMU TCG!

I additionally measured the performance of this new implementation
with this simple benchmark:
https://gist.github.com/spholz/b06ea737b435ecc181069cf0d911faa4

Based on to this benchmark, an unroll level 8 seems like a good choice
for all tested systems.

Here are the speedups for n=0x10000:
- Raspberry Pi 5:        7.6 ( 81984 ns -> 10748 ns)
- Raspberry Pi 4:        3.3 (131197 ns -> 39704 ns)
- StarFive VisionFive 2: 5.5 (279107 ns -> 50650 ns)
- AArch64 QEMU TCG:      6.8 (374287 ns -> 54847 ns)
- RISC-V QEMU TCG:       6.7 (354195 ns -> 52615 ns)
- x86-64 QEMU KVM:       3.8 ( 32443 ns ->  8542 ns)

Author: spholz

Kernel/Library/MiniStdLib.cpp

@@ -70,10 +70,37 @@ void* memset(void* dest_ptr, int c, size_t n)
         : "a"(c)
         : "memory");
 #else
-    u8* pd = (u8*)dest_ptr;
-    for (; n--;)
-        *pd++ = c;
+    auto* dest = static_cast<u8*>(dest_ptr);
+
+    auto is_word_aligned = [](auto ptr) {
+        return reinterpret_cast<FlatPtr>(ptr) % sizeof(FlatPtr) == 0;
+    };
+
+    // Set bytes until destination is word-aligned.
+    while (n > 0 && !is_word_aligned(dest)) {
+        *dest++ = static_cast<u8>(c);
+        n--;
+    }
+
+    // Set in word-sized chunks.
+    FlatPtr exploded = explode_byte(c);
+
+    auto* dest_word = reinterpret_cast<FlatPtr*>(dest);
+
+#    pragma GCC unroll 8
+    while (n >= sizeof(FlatPtr)) {
+        *dest_word++ = exploded;
+        n -= sizeof(FlatPtr);
+    }
+    dest = reinterpret_cast<u8*>(dest_word);
+
+    // Set remaining tail bytes.
+    while (n > 0) {
+        *dest++ = static_cast<u8>(c);
+        n--;
+    }
 #endif
+
     return dest_ptr;
 }