On Monday, 22 January 2024 at 10:23:55 UTC, ryuukk_ wrote:

I know: I've already submitted PR to dmd and phobos :)

For example, this one. Easy, fast, insecure (who cares, in this case).
http://www.isthe.com/chongo/tech/comp/fnv/

Andrea

On Monday, 22 January 2024 at 13:47:34 UTC, Andrea Fontana wrote:

The right one is FNV-1a:
http://www.isthe.com/chongo/src/fnv/hash_32a.c

On Monday, 22 January 2024 at 13:48:20 UTC, Andrea Fontana wrote:

Probably xxhash is even faster, but there's no public domain implementation.

On Monday, 22 January 2024 at 13:48:20 UTC, Andrea Fontana wrote:

FNV1A is used for hashOf. HashOf seems to be a lot faster than md5 only when you're dealing with smaller strings. I've done a test online and you'll see, this won't do actual difference in compilation time:

import std;

    auto test(T)(scope T delegate() dg)
    {
        import std.datetime.stopwatch;
        StopWatch sw = StopWatch(AutoStart.yes);
        scope(exit){writeln(sw.peek.total!"msecs");}
        return dg();
    }

    string repeat(string a, int n)
    {
        char[] ret = new char[](a.length*n);
        foreach(i; 0..n)
            ret[i*a.length..(i+1)*a.length] = a[];
        return cast(string)ret;
    }
    void main()
    {
        import std.digest.md;

        foreach(count; [1, 5, 10, 15, 25, 35, 50, 100, 200])
        {
        	string testString = "a".repeat(count);

            writeln("\nResult for 1_000_000 times executing hashes for a string if size ", count);
            test(()
                 {
                     foreach(i; 0..1_000_000)
                         hashOf(testString);
                 });
            test(()
                 {
                     foreach(i; 0..1_000_000)
                         md5Of(testString);
                 });
        }
    }

This is the result I have for this program:

Result for 1_000_000 times executing hashes for a string if size 1
12
130

Result for 1_000_000 times executing hashes for a string if size 5
25
132

Result for 1_000_000 times executing hashes for a string if size 10
36
129

Result for 1_000_000 times executing hashes for a string if size 15
41
124

Result for 1_000_000 times executing hashes for a string if size 25
54
127

Result for 1_000_000 times executing hashes for a string if size 35
69
120

Result for 1_000_000 times executing hashes for a string if size 50
94
116

Result for 1_000_000 times executing hashes for a string if size 100
176
217

Result for 1_000_000 times executing hashes for a string if size 200
379
394

As you see, this is a result for 1 million times hashing strings. I can't even think in many situations people would be doing 1 million time hashings. For a big program, you'll probably get 200 string literals. And if you test, it is still 0 milliseconds. So, MD5 is a pretty solution for that problem, and this would be too much effort for actually no gain at all, it could even create duplicate strings for no millisecond gain :)

On Monday, 22 January 2024 at 14:22:33 UTC, Hipreme wrote:

import std;

    auto test(T)(scope T delegate() dg)
    {
        import std.datetime.stopwatch;
        StopWatch sw = StopWatch(AutoStart.yes);
        scope(exit){writeln(sw.peek.total!"msecs");}
        return dg();
    }

    string repeat(string a, int n)
    {
        char[] ret = new char[](a.length*n);
        foreach(i; 0..n)
            ret[i*a.length..(i+1)*a.length] = a[];
        return cast(string)ret;
    }
    void main()
    {
        import std.digest.md;

        foreach(count; [1, 5, 10, 15, 25, 35, 50, 100, 200])
        {
        	string testString = "a".repeat(count);

            writeln("\nResult for 1_000_000 times executing hashes for a string if size ", count);
            test(()
                 {
                     foreach(i; 0..1_000_000)
                         hashOf(testString);
                 });
            test(()
                 {
                     foreach(i; 0..1_000_000)
                         md5Of(testString);
                 });
        }
    }

Result for 1_000_000 times executing hashes for a string if size 1
12
130

Result for 1_000_000 times executing hashes for a string if size 5
25
132

Result for 1_000_000 times executing hashes for a string if size 10
36
129

Result for 1_000_000 times executing hashes for a string if size 15
41
124

Result for 1_000_000 times executing hashes for a string if size 25
54
127

Result for 1_000_000 times executing hashes for a string if size 35
69
120

Result for 1_000_000 times executing hashes for a string if size 50
94
116

Result for 1_000_000 times executing hashes for a string if size 100
176
217

Result for 1_000_000 times executing hashes for a string if size 200
379
394

It hashes class name, they'll probably never be more than 30 characters, so md5 in your example would be 2x slower

I think it worth doing more benchmarks, even few milliseconds gained is worthwhile, that's milliseconds you could spend doing more template work for example, it's additive

On Monday, 22 January 2024 at 15:46:02 UTC, ryuukk_ wrote:

Indeed. And probably xxhash would be even faster if well optimized, I guess.

Andrea