How can I copy a repeating pattern into a memory buffer?

Question

I want write a repeating pattern of bytes into a block of memory. My idea is to write the first example of the pattern, and then copy it into the rest of the buffer. For example, if I start with this:

ptr: 123400000000

Afterward, I want it to look like this:

ptr: 123412341234

I thought I could use memcpy to write to intersecting regions, like this:

memcpy(ptr + 4, ptr, 8);

The standard does not specify what order the copy will happen in, so if some implementation makes it copy in reverse order, it can give different results:

ptr: 123412340000

or even combined results.

Is there any workaround that lets me still use memcpy, or do I have to implement my own for loop? Note that I cannot use memmove because it does exactly what I'm trying to avoid; it make the ptr be 123412340000, while I want 123412341234.

I program for Mac/iPhone(clang compiler) but a general answer will be good too.

Answer 1

Here is what kernel.org says:

The memcpy() function copies n bytes from memory area src to memory area dest. The memory areas must not overlap. Use memmove(3) if the memory areas do overlap.

An here is what MSDN says:

If the source and destination overlap, the behavior of memcpy is undefined. Use memmove to handle overlapping regions.

Answer 2

There is no standard function to repeat a pattern of bytes upon a memory range. You can use the memset_pattern* function family to get fixed-size patterns; if you need the size to vary, you'll have to roll your own.

// fills the 12 first bytes at `ptr` with the 4 first bytes of `ptr`
memset_pattern4(ptr, ptr, 12);

Be aware that memset_pattern4, memset_pattern8 and memset_pattern16 exist only on Mac OS/iOS, so don't use them for cross-platform development.

Otherwise, rolling a (cross-platform) function that does a byte-per-byte copy is pretty easy.

void byte_copy(void* into, void* from, size_t size)
{
    for (size_t i = 0; i < size; i++)
        into[i] = from[i];
}

Answer 3

The C++ answer for all platforms is std::fill_n(destination, elementRepeats, elementValue).

For what you've asked for:

short val = 0x1234;
std::fill_n(ptr, 3, val); 

This will work for val of any type; chars, shorts, ints, int64_t, etc.

Answer 4

You can do that by copying once, and then memcpy everything to copied to the following bytes and repeat that, it's better understood in code:

void block_memset(void *destination, const void *source, size_t source_size, size_t repeats) {
    memcpy(destination,source,source_size);
    for (size_t i = 1; i < repeats; i += i)
        memcpy(destination + i,destination,source_size * (min(i,repeats - i)));
}

I benchmarked; it's as fast as regular memset for large number of repeats, and the source_size is quite dynamic without much performance penalty too.

Answer 5

Old answer

You want memmove(). Full description:

The memmove() function shall copy n bytes from the object pointed to by s2 into the object pointed to by s1. Copying takes place as if the n bytes from the object pointed to by s2 are first copied into a temporary array of n bytes that does not overlap the objects pointed to by s1 and s2, and then the n bytes from the temporary array are copied into the object pointed to by s1.

From the memcpy() page:

If copying takes place between objects that overlap, the behaviour is undefined.

You have to use memmove() anyway. This is because the result of using memcpy() is not reliable in any way.

Relevant bits to the actual question

You're asking for memcpy(ptr + 4, ptr, 8); which says copy 8 bytes from ptr and put them at ptr+4. ptr is 123400000000, the first 8 bytes are 1234000, so it is doing this:

Original : 123400000000
Writes   :     12340000
Result   : 123412340000

You'd need to call:

memcpy(ptr+4, ptr, 4);
memcpy(ptr+8, ptr, 4);

To achieve what you're after. Or implement an equivalent. This ought to do it, but it is untested, and is equivalent to memcpy; you'll need to either add the extra temporary buffer or use two non-overlapping areas of memory.

void memexpand(void* result, const void* start, 
               const uint64_t cycle, const uint64_t limit)
{
    uint64_t count = 0;
    uint8_t* source = start;
    uint8_t* dest   = result;

    while ( count < limit )
    {
        *dest = *source;
        dest++;
        count++;

        if ( count % cycle == 0 )
        {
            source = start;
        }
        else
        {
            source++;
        }
    }
}

Answer 6

Why not just allocate an 8 byte buffer, move it there, then move it back to where you want it? (As @cnicutar says, you shouldn't have overlapping address spaces for memcpy.)