Optimization For Array Overload of std.conv.parse

[JackStouffer]

LDC

# new
Total time: 6 secs, 244 ms, 694 μs, and 2 hnsecs

# old
Total time: 8 secs, 555 ms, 476 μs, and 5 hnsecs

DMD

# new
Total time: 10 secs, 220 ms, 605 μs, and 5 hnsecs

# old
Total time: 14 secs, 600 ms, 397 μs, and 1 hnsec

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;

Target parse1(Target, Source)(ref Source s, dchar lbracket = '[', dchar rbracket = ']', dchar comma = ',')
    if (isSomeString!Source && !is(Source == enum) &&
        isDynamicArray!Target && !is(Target == enum))
{
    import std.array : appender;

    auto result = appender!Target();

    parseCheck!s(lbracket);
    skipWS(s);
    if (s.empty)
        throw new ConvException("");
    if (s.front == rbracket)
    {
        s.popFront();
        return result.data;
    }
    for (;; s.popFront(), skipWS(s))
    {
        result ~= parseElement!(ElementType!Target)(s);
        skipWS(s);
        if (s.empty)
            throw new ConvException("");
        if (s.front != comma)
            break;
    }
    parseCheck!s(rbracket);

    return result.data;
}

void skipWS(R)(ref R r)
{
    import std.ascii : isWhite;
    static if (isSomeString!R)
    {
        //Implementation inspired from stripLeft.
        foreach (i, dchar c; r)
        {
            if (!isWhite(c))
            {
                r = r[i .. $];
                return;
            }
        }
        r = r[0 .. 0]; //Empty string with correct type.
        return;
    }
    else
    {
        for (; !r.empty && isWhite(r.front); r.popFront())
        {}
    }
}

void parseCheck(alias source)(dchar c, string fn = __FILE__, size_t ln = __LINE__)
{
    if (source.empty)
        throw new ConvException(text("unexpected end of input when expecting", "\"", c, "\""));
    if (source.front != c)
        throw new ConvException(text("\"", c, "\" is missing"), fn, ln);
    source.popFront();
}

__gshared char[] test = ['[', '1', ',', '2', ',', '3', ',', '4', ',', '5', ']'];

void main()
{
    enum n = 20_000_000;

    int[] result;
    StopWatch sw;
    Duration sum;
    TickDuration last = TickDuration.from!"seconds"(0);

    foreach(i; 0 .. n)
    {
        sw.start();

        // New
        result = parse1!(int[])(test);

        // Old
        //result = parse!(int[])(test);

        sw.stop();

        test = ['[', '1', ',', '2', ',', '3', ',', '4', ',', '5', ']'];
        auto time = sw.peek() - last;
        last = sw.peek();

        sum += time.to!Duration();
    }

    writeln("Total time: ", sum);
}

[UplinkCoder]

Your comment is just a hunk of code.
Please explain what you did.

in this case:
"Used appender instead of dynamic array."

this will pissmize performance in some cases.

[JackStouffer]

Your comment is just a hunk of code.

This code is the performance benchmark.

Please explain what you did.

Replaced the dynamic array with an Appender.

this will pissmize performance in some cases.

Please give an example.

[wilzbach]

LGTM - Appender is a lot more opportunitistic in pre-allocating memory than D's builtin Array. Though I it would never hurt to fine tune that as well ;-)

[JackStouffer]

Auto-merge toggled on