Opportunity: Software Execution Time Determinism

[Nordlöw via Digitalmars-d]

I'm currenly in an industry with extremely high demands on 
software determinism, both in space and time (hard realtime).

My conclusion so far is that most safety-critical industries 
today are in desperate need of better (any) language support for 
guaranteeing determinism, especially time. The amount of 
time/money spent/wasted on complicated extra tooling processes 
and tests to assure time-determinism is just insane, at least in 
the avionics industry.

If D was to attack this problem in the same systematic way it can 
restrict execution behaviour with `@safe pure nothrow @nogc` D 
would have yet another killing feature in its feature pack.

I'm aware of the lack of absolute time-determinism in the CPU 
architectures of today. But the industry still uses such 
architectures, sometimes with memory-caches disabled and 
forbidding of multi-core/cpu in its products.

Have anybody though about adding support for this in D? I assume 
it would have to integrate with the backend in various 
complicated ways. Both the frontend and the backend would need to 
have options for generation of code that promotes deterministic 
execution over smallest average time-execution (which is 
currently the default optimization route taken by most compilers 
and library algorithms).

Are there any languages or compilers that tries to attack this 
problem?

Note that this problem is highly related to concept of 
"cyclomatic complexity".

See also:

https://en.wikipedia.org/wiki/Cyclomatic_complexity