Thread overview | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
March 30, 2015 Benchmark block | ||||
---|---|---|---|---|
| ||||
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? |
March 30, 2015 Re: Benchmark block | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jonathan | 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?
|
March 30, 2015 Re: Benchmark block | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jonathan | 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 |
March 31, 2015 Re: Benchmark block | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jonathan | 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
|
March 31, 2015 Re: Benchmark block | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jonathan | 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
|
March 31, 2015 Re: Benchmark block | ||||
---|---|---|---|---|
| ||||
Posted in reply to w0rp | 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 |
March 31, 2015 Re: Benchmark block | ||||
---|---|---|---|---|
| ||||
Posted in reply to lobo | > 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
|
March 31, 2015 Re: Benchmark block | ||||
---|---|---|---|---|
| ||||
Posted in reply to Andrei Alexandrescu | >> @kind("benchmark") unittest
Is this possible currently?
|
March 31, 2015 Re: Benchmark block | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jonathan | 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.
|
March 31, 2015 Re: Benchmark block | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jonathan | 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)
{
...
}
|
Copyright © 1999-2021 by the D Language Foundation