I have no idea if this has been discussed yet, but I was thinking it would be neat to have benchmark blocks that only run when specified, like how unittest works.

Code:

benchmarks
{
 import std.conv : to;
 int a;
 void f() {auto b = to!string(a);}
 auto r = benchmark!(f)(10_000);
 auto f0Result = to!Duration(r[0]);
 writeln(f0Result)
}

Example:
rdmd -benchmarks -main myapp.d

Alternatively, the writeln could be replaced with some kind of standard benchmark output utility (similar to the idea of assert when used for unit tests).

Thoughts?

On Monday, 30 March 2015 at 23:29:40 UTC, Jonathan wrote:
> I have no idea if this has been discussed yet, but I was thinking it would be neat to have benchmark blocks that only run when specified, like how unittest works.
>
> Code:
>
> benchmarks
> {
>  import std.conv : to;
>  int a;
>  void f() {auto b = to!string(a);}
>  auto r = benchmark!(f)(10_000);
>  auto f0Result = to!Duration(r[0]);
>  writeln(f0Result)
> }
>
> Example:
> rdmd -benchmarks -main myapp.d
>
> Alternatively, the writeln could be replaced with some kind of standard benchmark output utility (similar to the idea of assert when used for unit tests).
>
> Thoughts?

I think this can be implemented via a library solution pretty neatly. I was playing with something recently, and I ended up writing an RAII benchmark thing.

{
   auto b = Benchmark("name here");

   // Run code here.
}

With the syntax above in mind, you can write a constructor and a destructor for Benchmark which start and stop a timer and then print the results. I got it working before, and it was kind of fun. Another idea is to do this.

@benchmark
void nameHere() {
    // Run code here.
}

Then you can write something or other which finds functions with the @benchmark attribute and runs a timer as before, etc.

Why add extra syntax for what you can already do pretty nicely with a library?

On Monday, 30 March 2015 at 23:29:40 UTC, Jonathan wrote:
> Thoughts?

Yes please, but as a part as phobos:
https://github.com/D-Programming-Language/phobos/pull/2995

On 3/30/15 4:29 PM, Jonathan wrote:
> I have no idea if this has been discussed yet, but I was thinking it
> would be neat to have benchmark blocks that only run when specified,
> like how unittest works.
>
> Code:
>
> benchmarks
> {
>   import std.conv : to;
>   int a;
>   void f() {auto b = to!string(a);}
>   auto r = benchmark!(f)(10_000);
>   auto f0Result = to!Duration(r[0]);
>   writeln(f0Result)
> }
>
> Example:
> rdmd -benchmarks -main myapp.d
>
> Alternatively, the writeln could be replaced with some kind of standard
> benchmark output utility (similar to the idea of assert when used for
> unit tests).
>
> Thoughts?

@kind("benchmark") unittest
{
   ...
}


Andrei

On Monday, 30 March 2015 at 23:29:40 UTC, Jonathan wrote:
> I have no idea if this has been discussed yet, but I was thinking it would be neat to have benchmark blocks that only run when specified, like how unittest works.
>
> Code:
>
> benchmarks
> {
>  import std.conv : to;
>  int a;
>  void f() {auto b = to!string(a);}
>  auto r = benchmark!(f)(10_000);
>  auto f0Result = to!Duration(r[0]);
>  writeln(f0Result)
> }
>
> Example:
> rdmd -benchmarks -main myapp.d
>
> Alternatively, the writeln could be replaced with some kind of standard benchmark output utility (similar to the idea of assert when used for unit tests).
>
> Thoughts?

Would this do what you're after?

version(benchmark) {
unittest {
  import std.conv : to;
  int a;
  void f() {auto b = to!string(a);}
  auto r = benchmark!(f)(10_000);
  auto f0Result = to!Duration(r[0]);
  writeln(f0Result)
 }
}

rdmd -main -- -version=benchmark -unittest myapp.d


Or something along those lines.

This will run all the normal unit tests as well as the benchmark tests, which I'd argue is a good thing anyway.

bye,
lobo

On 2015-03-31 01:40, w0rp wrote:

> Why add extra syntax for what you can already do pretty nicely with a
> library?

It would be nice if D could support a generic syntax for trailing delegates, i.e.

benchmarks
{

}

Would be lowered to:

benchmarks({

});

Then it can be implemented as a library solution with a nice syntax that looks built-in.

-- 
/Jacob Carlborg

> Would this do what you're after?
>
> version(benchmark) {
> unittest {
>   import std.conv : to;
>   int a;
>   void f() {auto b = to!string(a);}
>   auto r = benchmark!(f)(10_000);
>   auto f0Result = to!Duration(r[0]);
>   writeln(f0Result)
>  }
> }
>
> rdmd -main -- -version=benchmark -unittest myapp.d

Well, I don't consider benchmarks <a kind of> unit test. So maybe just this:

version(benchmark) {
  import std.conv : to;
  int a;
  void f() {auto b = to!string(a);}
  auto r = benchmark!(f)(10_000);
  auto f0Result = to!Duration(r[0]);
  writeln(f0Result)
}

rdmd -main -- -version=benchmark myapp.d

>> @kind("benchmark") unittest

Is this possible currently?

On Monday, 30 March 2015 at 23:29:40 UTC, Jonathan wrote:
> I have no idea if this has been discussed yet, but I was thinking it would be neat to have benchmark blocks that only run when specified, like how unittest works.
>
> Code:
>
> benchmarks
> {
>  import std.conv : to;
>  int a;
>  void f() {auto b = to!string(a);}
>  auto r = benchmark!(f)(10_000);
>  auto f0Result = to!Duration(r[0]);
>  writeln(f0Result)
> }
>
> Example:
> rdmd -benchmarks -main myapp.d
>
> Alternatively, the writeln could be replaced with some kind of standard benchmark output utility (similar to the idea of assert when used for unit tests).
>
> Thoughts?

Thinking that there is "unittest" already, and other people might want other code parts, this turns into labelled code parts.

code( kind: benchmark ){
}

code( kind: unittest ){
}

code( kind: release ){
}

etc.

On Monday, 30 March 2015 at 23:29:40 UTC, Jonathan wrote:
> I have no idea if this has been discussed yet, but I was thinking it would be neat to have benchmark blocks that only run when specified, like how unittest works.
>
> Code:
>
> benchmarks
> {
>  import std.conv : to;
>  int a;
>  void f() {auto b = to!string(a);}
>  auto r = benchmark!(f)(10_000);
>  auto f0Result = to!Duration(r[0]);
>  writeln(f0Result)
> }
>
> Example:
> rdmd -benchmarks -main myapp.d
>
> Alternatively, the writeln could be replaced with some kind of standard benchmark output utility (similar to the idea of assert when used for unit tests).
>
> Thoughts?

version(benchmark)
{
    ...
}