Slight optimization for std.conv.text/wtext/dtext

[JackStouffer]

Increase the performance of textImpl by

• Reducing GC allocations with numbers by using toChars rather than to, which allocates a temporary array and then throws it away
• Using a very dumb heuristic to pre-allocate space for the elements

Just adding the toChars case gave a small boost in LDC and no difference in DMD. But, the heuristic added a lot of performance.

Recording performance gains of 12.8% with LDC and 5.5% with DMD

$ ldc2 -O5 -release test.d && ./test
result	1 sec, 435 ms, 49 μs, and 4 hnsecs
result2	1 sec, 251 ms, 957 μs, and 6 hnsecs

$ dmd -O -inline -release -noboundscheck test.d &&./test
result	2 secs, 510 ms, 745 μs, and 2 hnsecs
result2	2 secs, 372 ms, 147 μs, and 4 hnsecs

The code

import std.stdio;
import std.range;
import std.algorithm;
import std.traits;
import std.container;
import std.meta;
import std.conv;
import std.datetime;

enum testCount = 1_000_000;

private S textImpl(S, U...)(U args)
{
    static if (U.length == 0)
    {
        return null;
    }
    else static if (U.length == 1)
    {
        return to!S(args[0]);
    }
    else
    {
        import std.array : appender;

        auto app = appender!S();

        foreach (arg; args)
            app.put(arg.to!S);

        return app.data;
    }
}


private S textImpl2(S, U...)(U args)
{
    static if (U.length == 0)
    {
        return null;
    }
    else static if (U.length == 1)
    {
        return to!S(args[0]);
    }
    else
    {
        import std.array : appender;

        auto app = appender!S();

        // assume that on average, parameters will have less
        // than 20 elements
        app.reserve(U.length * 20);

        foreach (arg; args)
        {
            static if (is(Unqual!T == uint) || is(Unqual!T == ulong) || is(Unqual!T == int) || is(Unqual!T == long))
                app.put(arg.toChars);
            else
                app.put(arg.to!S);
        }

        return app.data;
    }
}


void main()
{
    auto result = to!Duration(benchmark!(() => textImpl!dstring(4243, ' ', 1.54321, ": xyz", 333, "Another test"))(testCount)[0]);
    auto result2 = to!Duration(benchmark!(() => textImpl2!dstring(4243, ' ', 1.54321, ": xyz", 333, "Another test"))(testCount)[0]);

    writeln("result", "\t", result);
    writeln("result2", "\t", result2);
}

[MetaLang]

static if (isIntegral!(Unqual!T))?

[JackStouffer]

I copied it from the constraint of toChars

[MetaLang]

Ah, I see. I wonder why toChars defines its constraint to only take u/ints and u/longs... Maybe I'll take a look sometime and see if it can be expanded/simplified.

[MetaLang]

LGTM with room for further improvements.

[DmitryOlshansky]

LGTM

[JackStouffer]

Auto-merge toggled on

[ibuclaw]

This caused a regression.

https://issues.dlang.org/show_bug.cgi?id=17712

[ghost]

This change make things working again.

@@ -4250,11 +4250,11 @@ private S textImpl(S, U...)(U args)
         {
             static if (
                 is(Unqual!(typeof(arg)) == uint) || is(Unqual!(typeof(arg)) == ulong) ||
                 is(Unqual!(typeof(arg)) == int) || is(Unqual!(typeof(arg)) == long)
             )
-                app.put(arg.toChars);
+                app.put(textImpl!(S)(arg));
             else
                 app.put(to!S(arg));
         }
 
         return app.data;

Maybe some templates got discarded because of variadic arg here ?

[ghost]

That maybe more simply because toChars is not called anymore.