Which is faster memmove or memcpy?

memcpy.

Glad I could help you with your homework.

inlined memcpy tends to get optimized really well.

memmove involves a temporary buffer, of course memcpy is faster. look at the man pages you idort

Their both aliased to bcopy.  Sorry for the real answer.

>>5
Conforming to
4.3BSD. This function is deprecated (marked as LEGACY in POSIX.1-2001): use memcpy() or memmove() in new programs. Note that the first two parameters are interchanged for memcpy() and memmove().

>>5
What about those peoples both aliased?

>>7
you're gay and cats like milk

Sagefault (thread bumped.)

REP MOVSB

>>8
My cat is homophobic and lactose intolerant.

>>11
that sucks I guess

>>10
good implementations use
REP MOVSD to move in groups of dwords, then do an "and _rest_reg,3" (mod 4) to calculate the remaining size, and rep movsb the rest if any.

>>13,10
http://fxr.watson.org/fxr/source/osfmk/i386/commpage/bcopy_sse3x_64.s?v=xnu-1228

/* Lets compare them! */

void * __cdecl memmove (
        void * dst,
        const void * src,
        size_t count
        )
{
        void * ret = dst;

#if defined (_M_IA64)
        {
        extern void RtlMoveMemory( void *, const void *, size_t count );

        RtlMoveMemory( dst, src, count );
        }
#else  /* defined (_M_IA64) */
        if (dst <= src || (char *)dst >= ((char *)src + count)) {
                /*
                 * Non-Overlapping Buffers
                 * copy from lower addresses to higher addresses
                 */
                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst + 1;
                        src = (char *)src + 1;
                }
        }
        else {
                /*
                 * Overlapping Buffers
                 * copy from higher addresses to lower addresses
                 */
                dst = (char *)dst + count - 1;
                src = (char *)src + count - 1;

                while (count--) {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst - 1;
                        src = (char *)src - 1;
                }
        }
#endif  /* defined (_M_IA64) */

        return(ret);
}


/**************************************************/



void * __cdecl memcpy (
        void * dst,
        const void * src,
        size_t count
        )
{
        void * ret = dst;

#if defined (_M_IA64)
        {
        extern void RtlMoveMemory( void *, const void *, size_t count );

        RtlMoveMemory( dst, src, count );
        }
#else  /* defined (_M_IA64) */
        /*
         * copy from lower addresses to higher addresses
         */
        while (count--) {
                *(char *)dst = *(char *)src;
                dst = (char *)dst + 1;
                src = (char *)src + 1;
        }
#endif  /* defined (_M_IA64) */

        return(ret);
}

>>13
Actually, the best results seem to be obtained with REP MOVSB followed by MOVSW if(count&2), and then MOVSB if(count&1).

>>13
Enjoy your unaligned access penalties.

>>17
I will along with my job

>>5
>Their both aliased to bcopy
Whose?
"both" belonging to who?
Your sentence is incomplete.

>>19
I am sentence is incomplete?  Maybe you should learn English buddy.

23 Name: Anonymous 2013-08-31 17:49

 my god this is bugged as fuck