Re: interrupting a function
On Saturday, 17 November 2018 at 08:17:36 UTC, Paul Backus wrote:
You could run the calculation in another thread and use
std.concurrency.receiveTimeout [1] to stop waiting for the
result after a certain amount of time.
Ok... would you say the following is a feasible alternative?
´´´
import std.experimental.all;
import core.thread;
auto assumeNoGC(T) (T t) if (isFunctionPointer!T || isDelegate!T)
{
enum attrs = functionAttributes!T | FunctionAttribute.nogc;
return cast(SetFunctionAttributes!(T, functionLinkage!T,
attrs)) t;
}
struct D
{
size_t d;
static S s;
}
struct S
{
size_t dummy;
D[] data;
}
struct Model
{
auto ref s()
{
return D.s;
}
size_t counter;
void run() @nogc
{
do
{
debug
{
"I'm running".writeln;
writeln(s.data.length);
writeln(s.dummy);
}
// some heavy work, which is nogc
Thread.sleep(1.seconds);
assumeNoGC((){
yield(); // is stack change a nogc action?
})();
counter++;
}while(counter < 10);
}
}
Fiber composed;
auto myCall()
{
return composed.call;
}
void main()
{
Model m;
composed = new Fiber( );
D.s.data.length = 4;
D.s.dummy = 42;
import std.datetime.stopwatch : Duration, benchmark;
Duration res;
bool abort;
while(composed.state != Fiber.State.TERM)
{
writeln(res == Duration.zero);
res += benchmark!(((myCall)))(1).front;
writeln(m.counter);
writeln(composed.state);
writeln(res);
writeln(res > 5.seconds);
if(res > 5.seconds)
{
abort = true;
break;
}
}
assert(abort);
}
´´´
Re: interrupting a function
On Saturday, 17 November 2018 at 08:17:36 UTC, Paul Backus wrote: You could run the calculation in another thread and use std.concurrency.receiveTimeout [1] to stop waiting for the result after a certain amount of time. [1] https://dlang.org/phobos/std_concurrency.html#.receiveTimeout Ah... yes. Thanks!
Re: interrupting a function
On Saturday, 17 November 2018 at 06:19:25 UTC, Alex wrote: It can happen, that the input params are correct, however, the calculation lasts too long. Is there a way, to measure the execution time of foo (á la benchmark) and then, if some execution time limit is exceeded to interrupt the calculation? At best, with a flag, whether foo ended normally or because of the interruption. You could run the calculation in another thread and use std.concurrency.receiveTimeout [1] to stop waiting for the result after a certain amount of time. [1] https://dlang.org/phobos/std_concurrency.html#.receiveTimeout
interrupting a function
I wished I never come across the nightmare of such a question.
And maybe, there is still a bug in my code, which I'm not aware
of (which I strongly suppose :/ ).
But nevertheless, and for learning purposes, assume I have
something like this:
´´´
auto foo(/*input params*/)
{
//some long calculations, depending on input params.
}
void main()
{
foo;
}
´´´
It can happen, that the input params are correct, however, the
calculation lasts too long. Is there a way, to measure the
execution time of foo (á la benchmark) and then, if some
execution time limit is exceeded to interrupt the calculation? At
best, with a flag, whether foo ended normally or because of the
interruption.
