DCompute - Native heterogeneous computing for D - is here!

[Nicholas Wilson via Digitalmars-d-announce]

DCompute is an extension to LDC capable of generating code (with 
no language changes*) for NVIDIA's NVPTX for use with CUDA, SPIRV 
for use with the OpenCL runtime, and of course the host, all at 
the same time! It is also possible to share implementation of 
algorithms across the host and device.
This will enable writing kernels in D utilising all of D's meta 
programming goodness across the device divide and will allow 
launching those kernels with a level of ease on par with CUDA's 
<<<...>>> syntax. I hope to be giving a talk at DConf2017 about 
this ;), what it enables us to do, what still needs to be done 
and future plans.

DCompute supports all of OpenCL except Images and Pipes (support 
is planned though).
I haven't done any test for CUDA so I'm not sure about the extent 
of support for it, all of the math stuff works, images/textures 
not so sure.

Many thanks to the ldc team (especially Johan) for their guidance 
and patience, Ilya for reminding me that I should upstream my 
work and John Colvin for his DConf2016 talk for making me think 
'surely compiler support can't be too hard'. 10 months later: 
here it is!

The DCompute compiler is available at the dcompute branch of ldc 
[0], you will need my fork of llvm here[1] and the SPIRV 
submodule that comes with it [2] as the llvm to link against. 
There is also a tool for interconversion [3] (I've mucked up the 
submodules a bit, sorry, just clone it into 'tools/llvm-spirv', 
it's not necessary anyway). The device standard library and 
drivers (both WIP) are available here[4].

Please sent bug reports to their respective components, although 
I'm sure I'll see them anyway regardless of where they go.

[0]: https://github.com/ldc-developers/ldc/tree/dcompute
[1]: https://github.com/thewilsonator/llvm/tree/compute
[2]: https://github.com/thewilsonator/llvm-target-spirv
[3]: https://github.com/thewilsonator/llvm-tool-spirv
[4]: https://github.com/libmir/dcompute

* modulo one hack related to resolving intrinsics because there 
is no static context (i.e. static if) for the device(s). 
Basically a 'codegen time if'.