Just creating a bunch (10k) of sleeping (for 100 msecs) goroutines/tasks.

Compilers
go:     go version go1.4.2 linux/amd64
vibe.d: DMD64 D Compiler v2.067.1 linux/amd64, vibe.d 0.7.23

Code
go:     http://pastebin.com/2zBnGBpt
vibe.d: http://pastebin.com/JkpwSe47

go version build with     "go build test.go"
vibe.d version built with "dub build --build=release test.d"

Results on my machine:

go:     168.736462ms (overhead ~ 68ms)
vibe.d: 1944ms       (overhead ~ 1844ms)

Why creating of vibe.d tasks is so slow (more then 10 times)???

On Tuesday, 30 June 2015 at 15:18:36 UTC, Jack Applegame wrote:
> Just creating a bunch (10k) of sleeping (for 100 msecs) goroutines/tasks.
>
> Compilers
> go:     go version go1.4.2 linux/amd64
> vibe.d: DMD64 D Compiler v2.067.1 linux/amd64, vibe.d 0.7.23
>
> Code
> go:     http://pastebin.com/2zBnGBpt
> vibe.d: http://pastebin.com/JkpwSe47
>
> go version build with     "go build test.go"
> vibe.d version built with "dub build --build=release test.d"
>
> Results on my machine:
>
> go:     168.736462ms (overhead ~ 68ms)
> vibe.d: 1944ms       (overhead ~ 1844ms)
>
> Why creating of vibe.d tasks is so slow (more then 10 times)???

Use GDC or LDC for profiling code; the DMD optimizer isn't as good.

Also, its likely that go has spent a lot more effort optimizing coroutines specifically than D has.

Don't have go installed, but for me, the timings don't change very much depending on compiler and optimization flags:

dub --compiler=dmd                     13346ms
dub --compiler=dmd --build=release     12348ms
dub --compiler=ldc2                    12082ms
dub --compiler=ldc2 --build=release     9351ms

On Tuesday, 30 June 2015 at 15:18:36 UTC, Jack Applegame wrote:
> Just creating a bunch (10k) of sleeping (for 100 msecs) goroutines/tasks.
>
> Compilers
> go:     go version go1.4.2 linux/amd64
> vibe.d: DMD64 D Compiler v2.067.1 linux/amd64, vibe.d 0.7.23
>
> Code
> go:     http://pastebin.com/2zBnGBpt
> vibe.d: http://pastebin.com/JkpwSe47
>
> go version build with     "go build test.go"
> vibe.d version built with "dub build --build=release test.d"
>
> Results on my machine:
>
> go:     168.736462ms (overhead ~ 68ms)
> vibe.d: 1944ms       (overhead ~ 1844ms)
>
> Why creating of vibe.d tasks is so slow (more then 10 times)???

I think this might be a problem with vibe.d's `sleep`. Putting a `writeln("...");` there is a lot faster than `sleep`ing even the tiniest amount of time.

On Tuesday, 30 June 2015 at 16:43:58 UTC, anonymous wrote:
> On Tuesday, 30 June 2015 at 15:18:36 UTC, Jack Applegame wrote:
>> Just creating a bunch (10k) of sleeping (for 100 msecs) goroutines/tasks.
>>
>> Compilers
>> go:     go version go1.4.2 linux/amd64
>> vibe.d: DMD64 D Compiler v2.067.1 linux/amd64, vibe.d 0.7.23
>>
>> Code
>> go:     http://pastebin.com/2zBnGBpt
>> vibe.d: http://pastebin.com/JkpwSe47
>>
>> go version build with     "go build test.go"
>> vibe.d version built with "dub build --build=release test.d"
>>
>> Results on my machine:
>>
>> go:     168.736462ms (overhead ~ 68ms)
>> vibe.d: 1944ms       (overhead ~ 1844ms)
>>
>> Why creating of vibe.d tasks is so slow (more then 10 times)???
>
> I think this might be a problem with vibe.d's `sleep`. Putting a `writeln("...");` there is a lot faster than `sleep`ing even the tiniest amount of time.

Sleep will almost certainly pause and block the fiber. Vibe.d only switches between them when there's IO to be done or something else from the event loop. A better way of comparing would be to actually do something: use channels to ping-pong back between the goroutines and use vibe.d's concurrency to send messages betweeen fibers. Whatever you do, don't sleep.

Atila

On Tuesday, 30 June 2015 at 17:37:38 UTC, Atila Neves wrote:
> Sleep will almost certainly pause and block the fiber. Vibe.d only switches between them when there's IO to be done or something else from the event loop.
Sleep blocks the fiber, but not the event loop. Because it isn't core.thread.Thread.sleep, but vibe.core.core.sleep - http://vibed.org/api/vibe.core.core/sleep

On Tuesday, 30 June 2015 at 15:18:36 UTC, Jack Applegame wrote:
> Just creating a bunch (10k) of sleeping (for 100 msecs) goroutines/tasks.
>
> Compilers
> go:     go version go1.4.2 linux/amd64
> vibe.d: DMD64 D Compiler v2.067.1 linux/amd64, vibe.d 0.7.23
>
> Code
> go:     http://pastebin.com/2zBnGBpt
> vibe.d: http://pastebin.com/JkpwSe47
>
> go version build with     "go build test.go"
> vibe.d version built with "dub build --build=release test.d"
>
> Results on my machine:
>
> go:     168.736462ms (overhead ~ 68ms)
> vibe.d: 1944ms       (overhead ~ 1844ms)
>
> Why creating of vibe.d tasks is so slow (more then 10 times)???

fwiw I have 151ms total time for go; 740 ms for ldc (O2 and singleobj), and 760ms for dmd.  on an old zoostorm running 64bit arch linux.

microbenchmarks may be testing many strange things, and it requires more expertise than I currently have to know where this might come from.

On Tuesday, 30 June 2015 at 15:18:36 UTC, Jack Applegame wrote:
> Just creating a bunch (10k) of sleeping (for 100 msecs) goroutines/tasks.
>
> Compilers
> go:     go version go1.4.2 linux/amd64
> vibe.d: DMD64 D Compiler v2.067.1 linux/amd64, vibe.d 0.7.23
>
> Code
> go:     http://pastebin.com/2zBnGBpt
> vibe.d: http://pastebin.com/JkpwSe47
>
> go version build with     "go build test.go"
> vibe.d version built with "dub build --build=release test.d"
>
> Results on my machine:
>
> go:     168.736462ms (overhead ~ 68ms)
> vibe.d: 1944ms       (overhead ~ 1844ms)
>
> Why creating of vibe.d tasks is so slow (more then 10 times)???

how do they compare if you replace the sleep with yield?

Same problem still extreamly slow

On Wed, 01 Jul 2015 03:28:01 +0000
"rsw0x" <anonymous@anonymous.com> wrote:

> On Tuesday, 30 June 2015 at 15:18:36 UTC, Jack Applegame wrote:
> > Just creating a bunch (10k) of sleeping (for 100 msecs) goroutines/tasks.
> >
> > Compilers
> > go:     go version go1.4.2 linux/amd64
> > vibe.d: DMD64 D Compiler v2.067.1 linux/amd64, vibe.d 0.7.23
> >
> > Code
> > go:     http://pastebin.com/2zBnGBpt
> > vibe.d: http://pastebin.com/JkpwSe47
> >
> > go version build with     "go build test.go"
> > vibe.d version built with "dub build --build=release test.d"
> >
> > Results on my machine:
> >
> > go:     168.736462ms (overhead ~ 68ms)
> > vibe.d: 1944ms       (overhead ~ 1844ms)
> >
> > Why creating of vibe.d tasks is so slow (more then 10 times)???
> 
> how do they compare if you replace the sleep with yield?

On Tuesday, 30 June 2015 at 15:18:36 UTC, Jack Applegame wrote:
> Just creating a bunch (10k) of sleeping (for 100 msecs) goroutines/tasks.
>
> Compilers
> go:     go version go1.4.2 linux/amd64
> vibe.d: DMD64 D Compiler v2.067.1 linux/amd64, vibe.d 0.7.23
>
> Code
> go:     http://pastebin.com/2zBnGBpt
> vibe.d: http://pastebin.com/JkpwSe47
>
> go version build with     "go build test.go"
> vibe.d version built with "dub build --build=release test.d"
>
> Results on my machine:
>
> go:     168.736462ms (overhead ~ 68ms)
> vibe.d: 1944ms       (overhead ~ 1844ms)
>
> Why creating of vibe.d tasks is so slow (more then 10 times)???

In your dub.json, can you use the following:

    "subConfigurations": {
        "vibe-d": "libasync"
    },
    "dependencies": {
        "vibe-d": "~>0.7.24-beta.3"
    },


Turns out it makes it much faster on my machine (371ms vs 1474ms). I guess it could be a good thing to investigate if we can make it the default in 0.7.25.