Did somebody say templates?

#include <cstddef>
#include <iostream>

template <std::size_t I, std::size_t N>
struct memcpy_helper {
    static void
    do_(char* dst, char* src) {
        dst[I] = src[I];
        memcpy_helper<I + 1, N>::do_(dst, src);
    }
};

template <std::size_t N>
struct memcpy_helper<N, N> {
    static void
    do_(char*, char*) { }
};

template <std::size_t N, typename T>
void
memcpy(T* dst, T* src) {
    memcpy_helper<0, N * sizeof(T)>::do_(reinterpret_cast<char*>(dst), reinterpret_cast<char*>(src));
}

int
main() {
    int src[]{1, 2, 3};
    int dst[3];
    
    memcpy<3>(dst, src);
    
    for (int i : dst)
        std::cout << i << '\n';
}

It's fast because there is no run-time loop!

On ARM CPUs, stmia and ldmia are usually better than single load/store instructions. Especially for memset, you can fill 8 registers with the value and write 32 bytes per instruction :) Or unroll it to 32 stmia instructions and get a whole KB per iteration. But dealing with unaligned addresses/non-multiple-of-32 size is a pain.

Mostly I'd be looking at why you're copying so much data around every frame in the first place.

Hey man, I don't think you can optimize 'memcpy()' or 'memset()' ...

see GNU implementation and actual optimization implemented https://fossies.org/dox/glibc-2.24/string_2memcpy_8c_source.html

You may be able to approximate by only copying 1 bytes of 2, but the unset memory will hold random data... is that really what you want?

However,, if you perfectly know what size is the memory, you can implement something like this

(less comparison are done => faster program)

(copying 8 bytes per 8 bytes => 8 times faster than byte by byte if working on a 64 bit system)

/** if we know src and dst are multiple of 64 bytes (8 uint64_t) */
void * memcpy(void * src, void * dst, size_t n) {
	uint64_t * s = (int *)src;
	size_t len = n / sizeof(uint64_t);
	uint64_t * ptr = (int *)dst;
	uint64_t * end = (int *)(dst + len);
	size_t i = 0;
	while (ptr < end) {
		*ptr++ = *s++; //1
		*ptr++ = *s++; //2
		*ptr++ = *s++; //...
		*ptr++ = *s++;
		*ptr++ = *s++;
		*ptr++ = *s++;
		*ptr++ = *s++;		
		*ptr++ = *s++; //8
	}
}