July 24, 2013
This isn't a constructive link, but this benchmark of D vs. Rust vs. Go just hit the reddit/programming front page.

Spoiler: D came out pretty well, but for some reason ldc gave significantly better results than gdc. It's unclear why since the author didn't release any code. Unfortunately the original post was written before the author tried ldc, so most of the post has the impression that D compilers/runtime/libraries currently aren't that much better than Rust. Which, unfortunately, he blamed on the GC.

original: http://togototo.wordpress.com/2013/07/23/benchmarking-level-generation-go-rust-haskell-and-d/

reddit link: http://www.reddit.com/r/programming/comments/1ixnf6/benchmarking_roguelike_level_generation_go_rust/
July 24, 2013
On 7/23/2013 9:16 PM, CJS wrote:
> This isn't a constructive link, but this benchmark of D vs. Rust vs. Go just hit
> the reddit/programming front page.
>
> Spoiler: D came out pretty well, but for some reason ldc gave significantly
> better results than gdc. It's unclear why since the author didn't release any
> code. Unfortunately the original post was written before the author tried ldc,
> so most of the post has the impression that D compilers/runtime/libraries
> currently aren't that much better than Rust. Which, unfortunately, he blamed on
> the GC.
>
> original:
> http://togototo.wordpress.com/2013/07/23/benchmarking-level-generation-go-rust-haskell-and-d/
>
>
> reddit link:
> http://www.reddit.com/r/programming/comments/1ixnf6/benchmarking_roguelike_level_generation_go_rust/
>

Please post your comment here to Reddit!
July 24, 2013
I was wrong about the code not being available. There's a link in the first paragraph of the original post that I completely missed.
July 24, 2013
On 7/23/13 9:23 PM, Walter Bright wrote:
>> reddit link:
>> http://www.reddit.com/r/programming/comments/1ixnf6/benchmarking_roguelike_level_generation_go_rust/
>
> Please post your comment here to Reddit!

Did. I tried to provide positive feedback. I'm mildly miffed how the text is so much at odds with the numbers - literally as if the text was written beforehand and the numbers collected at the last minute.


Andrei
July 24, 2013
On Jul 24, 2013 5:20 AM, "CJS" <Prometheus85@hotmail.com> wrote:
>
> This isn't a constructive link, but this benchmark of D vs. Rust vs. Go
just hit the reddit/programming front page.
>
> Spoiler: D came out pretty well, but for some reason ldc gave
significantly better results than gdc. It's unclear why since the author didn't release any code.

I see that he used different back end for gdc/gcc - so the newer gcc might have some improvements over the older gdc.  And as Walter pointed out, he probably left bounds checking on for the compiler tests.  ;)

Regards
-- 
Iain Buclaw

*(p < e ? p++ : p) = (c & 0x0f) + '0';


July 24, 2013
On Wednesday, 24 July 2013 at 04:16:45 UTC, CJS wrote:
> This isn't a constructive link, but this benchmark of D vs. Rust vs. Go just hit the reddit/programming front page.

Hacker News:
https://news.ycombinator.com/item?id=6094668
July 24, 2013
Am 24.07.2013 06:16, schrieb CJS:
> This isn't a constructive link, but this benchmark of D vs. Rust
> vs. Go just hit the reddit/programming front page.
>
> Spoiler: D came out pretty well, but for some reason ldc gave
> significantly better results than gdc. It's unclear why since the
> author didn't release any code. Unfortunately the original post
> was written before the author tried ldc, so most of the post has
> the impression that D compilers/runtime/libraries currently
> aren't that much better than Rust. Which, unfortunately, he
> blamed on the GC.
>
> original:
> http://togototo.wordpress.com/2013/07/23/benchmarking-level-generation-go-rust-haskell-and-d/
>
> reddit link:
> http://www.reddit.com/r/programming/comments/1ixnf6/benchmarking_roguelike_level_generation_go_rust/
>

what im missing in the source is the benchmark environment:
and the info how many cycles where runned

what im missing is a program like

for(...1000)
{
  benchmark(D.executable)
  benchmark(C.executable)
  benchmark(Haskell.executable)
  ...
}

average
  D.executable
  C.executable
  Haskell.executable


July 24, 2013
This comment is worrying:

"Can you try D version without std.random, and use srand and rand from std.c.stdlib? I think it should be almost same speed as C version ;-)"

"Wow! Just tried that, and this brings the running time of the DMD-compiled version to 0.770s from 1.290, the GDC-compiled version from 1.060 to 0.680s, and the LDC version to 0.580s from 0.710s. Meaning the LDC version is on par with the Clang-compiled C version and just slightly beats the GCC-compiled C one! There really should be a warning note in the std.random library documentation that for performance-critical code the C stdlib random generator is a better choice."


Is this just because RNGs are value types? It's literally causing bad press for D, so this needs to be high on the priority list.
July 24, 2013
Am 24.07.2013 09:20, schrieb Peter Alexander:
> This comment is worrying:
>
> "Can you try D version without std.random, and use srand and rand
> from std.c.stdlib? I think it should be almost same speed as C
> version ;-)"
>
> "Wow! Just tried that, and this brings the running time of the
> DMD-compiled version to 0.770s from 1.290, the GDC-compiled
> version from 1.060 to 0.680s, and the LDC version to 0.580s from
> 0.710s. Meaning the LDC version is on par with the Clang-compiled
> C version and just slightly beats the GCC-compiled C one! There
> really should be a warning note in the std.random library
> documentation that for performance-critical code the C stdlib
> random generator is a better choice."
>
>
> Is this just because RNGs are value types? It's literally causing
> bad press for D, so this needs to be high on the priority list.
>

that was my second thought - what is benchmarked more
the std library or the code-generation itself

for an pure code-generation test he should implement the stdc random
in pure D, go, Haskell whatever and get rid of the printf stuff - that would give better results

or he should try to use different random implementations, (but still get rid of the io stuff)
July 24, 2013
On 24 July 2013 07:20, Andrei Alexandrescu <SeeWebsiteForEmail@erdani.org> wrote:
> On 7/23/13 9:23 PM, Walter Bright wrote:
>>>
>>> reddit link:
>>>
>>> http://www.reddit.com/r/programming/comments/1ixnf6/benchmarking_roguelike_level_generation_go_rust/
>>
>>
>> Please post your comment here to Reddit!
>
>
> Did. I tried to provide positive feedback. I'm mildly miffed how the text is so much at odds with the numbers - literally as if the text was written beforehand and the numbers collected at the last minute.
>
>

I see it more as a test between standard library implementations myself... for instance, there's almost no comparative difference between gcc/gdc if I was to take his C implementation and alter it as needed to turn it into D.  :o)

--
Iain Buclaw
« First   ‹ Prev
1 2 3 4 5 6 7 8
Top | Discussion index | About this forum | D home