• Alex (21/21) Nov 16 2018 I wished I never come across the nightmare of such a question.
• Paul Backus (5/11) Nov 17 2018 You could run the calculation in another thread and use
• Alex (2/7) Nov 17 2018 Ah... yes. Thanks!
• Alex (80/83) Nov 26 2018 Ok... would you say the following is a feasible alternative?

Alex <sascha.orlov gmail.com> writes:

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.

Paul Backus <snarwin gmail.com> writes:

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

Alex <sascha.orlov gmail.com> writes:

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!

Alex <sascha.orlov gmail.com> writes:

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( &m.run );

	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);
}
´´´