No, that won't work as you intend.

There is a new compiler Sambamba

that parallelizes automatically, but

for CPUs, not for GPUs.

http://phys.org/news/2015-03-scientists-parallel.html

http://www.sambamba.org/

In GPU programming, a huge set of processors

executes the same function called the kernel.

The threads that are running are only

distinguished by coordinates (1, 2, or 3

dimensions of a grid), and these coordinates

can be used to identify the part of the

problem they have to work on.

See "Thread execution" and following chapters in

http://www.uio.no/studier/emner/matnat/ifi/INF3380/v12/undervisningsmateriale/inf3380-gpu-2012.pdf

And "GPU kernels" (page 16) in

http://hci.iwr.uni-heidelberg.de/Staff/bgoldlue/cuda_ss_2012/cuda_ss_2012_00_intro.pdf

http://hci.iwr.uni-heidelberg.de/Staff/bgoldlue/cuda_ss_2012.php

Regards,

Joachim

try CUDA

try thrust c++ template library https://thrust.github.io/

OpenACC allows to make your code run on GPUs, however it still requires some sort of programming. You need to add pragmas similar to those in OpenMP. OpenACC does allow you to use GPU for computations, but efficient tuning is required. Of course it's less time demanding than coding from scratch, but at the same time hand coded program will run much faster.

An other alternative is OpenCL which is similar to CUDA. You would still have to re-write a part of your code.

I would go for OpenACC to try a simple and fast GPU parallelization and then I would try to go for a CUDA/OpenCL implementation if needed.

C++ AMP (C++ Accelerated Massive Parallelism) could  be useful. It requires you to write your C++ in a certain style and it does the offloading to GPU "automagically" for you. It also has  libraries for common parallel  patterns. 

https://msdn.microsoft.com/en-us/library/hh265136.aspx

https://bitbucket.org/multicoreware/cppamp-driver-ng/wiki/Home

The"somewhat parallelised  code -- what was used to parallelise it (eg openMP or MPI ,Silk, Template libray etc)? Then is the data parallelised or task parallelised.  If data (most likely) then you might want to use GPUs otherwise use threads and CPUs- ie use what you have.  If you decide to use a GPU  - I would advise OpenCL (don't get locked into NVidia's CUDA) . Microsoft's AMP is in support of  Microsoft. The Opencl Consortium is supplier-independent and it is attempting to be truly heterogeneous (multi-hardware vendors and multi hardware devices).   To use GPU s requires vendor specific kernels OpenCL will allow you to build and load these and interact with the rest or your system (in C++ and C)  via a downloadable SDK from that vendor. This then means that you must re-write the essential data processing parts as kernels on the chosen (openCL-ready) GPUs. The OpenCL facilities then allow you to manipulate the data parallism by distributing the data to all of the GPU processors (as multiple threads per processor). The SDK will include a kernel compiler for the given GPU and uses  internal schedulers (configured by the number of threads per processor and the number of processors as an index into a processing space, The kernel is automatically loaded into each thread (SIMD).  Now if you want to involve a GPU that is a flavour of what you will need to do using for example Opencl. It is why openMP and MPI tools tend to configure CPUs and now why OpenACC seems to be touted  - they are catching up with concept of heterogeneous parallel systems.  As different groups add to the muddle it will become further confused.  The key will be: what devices have they included in the various downloadable components.  That is why it needs to be a consortium of vendors (as for OpenCL).

So the answer to your question is: NO

CPU and GPU programming are very different. With a parallel CPU program, you usually have a limited number of processors, and you want to limit the amount of communication between the processes (low granularity).

To be efficient on a GPU, you need to execute a huge number of small tasks, that are all the same (but on different data) (high granularity). 

Therefore, it is not really possible to efficiently convert CPU code to GPU automatically.

To add one more option to the above mentioned, which will also include a refactoring of your code:

OMPSs (https://pm.bsc.es/ompss) is a programming model based on tasks and data dependencies between them. The praallelisation itself is done during runtime by a runtime environment which is compiled into your code by using the library.

You need to instrument your code with specific pragmas and compile with a special compiler. Documenatation and all necessary software is downloadable from the link above.

The OMPSs framework makes it possible to compile for different targets, GPGPUs being one of them.

This will probably not give you the same efficiency than programming CUDA yourself, but is probably much faster in terms of invested programming time.

OpenMP 4.0 (on latest GCC 4.9) will offload work to a GPU if asked.  You can then use the same OpenMP code for CPU and GPU. Not sure how efficient it is as it is a new release but it is simple (as these things go).

J.

In general it is not possible to compile regular C++ code for the GPU. It depends on your approach to parallelization if it is possible to easily port it to the GPU.

Direct programming of the GPU is done with OpenCL (which is a C dialect) or CUDA (which is a C++11 dialect). CUDA has the restriction that it only runs on NVIDIA graphic cards (and on x86 CPUs when compiled with PGI). CUDA would have the advantage that direct porting of C++ code is quite easy (though it needs some adaptations), but then with poor performance. For good performance, both CUDA and OpenCL require you to understand GPUs and tweak your code specifically for your platform.

As others have mentioned, there are libraries like Thrust and C++ Amp which allow to use GPUs on a higher level. They will require a full rewrite of your algorithms using one of these libraries. Your CPU and GPU code will diverge eventually.

If you are already using OpenMP for parallelization you just need to upgrade to a newer version of your compiler supporting OpenMP 4.0. You can use annotations to select an accelerator (i.e. the GPU) instead of the CPU. In addition to these small changes you also have to add annotations to make the data available to the GPU. If you are already using OpenMP this is the easiest way and will give you moderate performance. OpenACC is comparable (though not compatible) to OpenMP's extension for accelerators. They probably have equivalent performance. But, you need a special compiler (e.g. PGI) to use OpenACC and I expect it to die quite soon because more people are already using OpenMP.

What does "22 boards" mean?  It is unlikely that you have a server which 22 plug-in processor cards (which might thus implement shared memory).  So are you talking about distributed memory?  Are you using MPI or something else for communication?  Or do you have a machine with 22 GPUs?

About GPUs, you have to remember that they are suited for computation which is fundamentally similar to graphics: lots of independent, data-parallel operations, on compact data, preferably without high-precision floating point.  But from 10k feet, quant stuff has a rep for being GPU-friendly...

New Nvidia volta boards "datacenters" do it, you can have 5120 32 bit cores (a half of 64k ones) and can be programmed in c++:

https://devblogs.nvidia.com/inside-volta/

It cost 3300$ at amazon, but seems to be a graphics card, but I do not know how to program c++ inside

It has 5 times speed of my radeon R9-390 and has a 3k sized bus instead of mine 256 bits

OpenCL works well with small encapsulated routines with low data throughput, if not it is the hell