Fix Issue 18239: fillWithMemcpy use memset when T.sizeof == 1

[n8sh]

Current function in std.experimental.allocator.package:

private void fillWithMemcpy(T)(void[] array, auto ref T filler) nothrow
{
    import core.stdc.string : memcpy;
    import std.algorithm.comparison : min;
    if (!array.length) return;
    memcpy(array.ptr, &filler, T.sizeof);
    // Fill the array from the initialized portion of itself exponentially.
    for (size_t offset = T.sizeof; offset < array.length; )
    {
        size_t extent = min(offset, array.length - offset);
        memcpy(array.ptr + offset, array.ptr, extent);
        offset += extent;
    }
}

When T.sizeof==1 we could use memset instead.

[dlang-bot]

Thanks for your pull request, @n8sh! We are looking forward to reviewing it, and you should be hearing from a maintainer soon.

Some tips to help speed things up:

• smaller, focused PRs are easier to review than big ones

• try not to mix up refactoring or style changes with bug fixes or feature enhancements

• provide helpful commit messages explaining the rationale behind each change

Bear in mind that large or tricky changes may require multiple rounds of review and revision.

Please see CONTRIBUTING.md for more information.

Bugzilla references

Auto-close	Bugzilla	Description
✓	18239	std.experimental.allocator fillWithMemcpy could use memset when T.sizeof==1

[wilzbach]

Why not cast(int) filler as the API expects?

pure nothrow @nogc @system void* memset(return void* s, int c, size_t n); 

https://dlang.org/phobos/core_stdc_string.html#.memset

For other reviewers are wondering too why int is required by the C header:

The value is passed as an int, but the function fills the block of memory using the unsigned char conversion of this value.

http://www.cplusplus.com/reference/cstring/memset/

[n8sh]

Why not cast(int) filler

My rationale is that it's possible for to T override opCast so cast(int) filler could return something whose low byte is not bitwise identical to T.init.

EDIT: And it might also not be legal to cast to int at all, e.g.
https://run.dlang.io/is/r1jeI2.

import std.stdio;
struct S
{
    char c;
}
void main()
{
    static assert(S.sizeof == 1);
    // This will fail to compile.
    writeln(cast(int) S.init);
}

as the API expects

ubyte will be promoted to int

[quickfur]

What about using a union to make the intent clearer, instead of that line noise complicated cast?

union U { T t; ubyte asByte; }
U u;
u.t = filler;
memset(array.ptr, u.filler, array.length);

[n8sh]

u.t = filler;

I need to avoid opAssign in order for this function to always have the same behavior as the existing fillWithMemcpy which never calls opAssign. I could do:

union U { Unqual!T t; ubyte asByte; }
U u = void;
memcpy(&u.t, &filler, 1);
memset(array.ptr, u.asByte, array.length);

if you think that would be clearer.

[quickfur]

Hmm. If you wish to avoid opAssign, I suppose there's really no other way than to dereference a pointer cast to ubyte. Fair enough.

[quickfur]

LGTM

[wilzbach]

Thanks a lot!