As Sunny said, the best approach depends on the purpose for which you intend to use the coprocessors, specifically, the pattern of parallelism and communication.
- If you can run two independent Linux processes to do your workload (batch processing scenario), you can use the native programming model and start jobs on coprocessors in parallel using "ssh" like you would on two independent general-purpose machines.
- If you have one process that has multiple independent work-items to compute ("embarrassingly parallel" code, no communication), you can use the offload model to send independent work-items to different coprocessors. Start two threads on the host and map each thread to the respective coprocessor:
const int nDevices = _Offload_number_of_devices();
#pragma omp parallel num_threads(nDevices)
{
const int i = omp_get_thread_num();
#pragma offload target(mic: i)
{
MyFunction(/*...*/ );
}
}
- In the same way you can distribute a set of work-items between coprocessors:
const int nDevices = _Offload_number_of_devices();
#pragma omp parallel num_threads(nDevices)
{
const int iDevice = omp_get_thread_num();
#pragma omp for schedule(dynamic, 1)
for (int i = 0; i < nWorkItems; i++) {
#pragma offload target(mic: iDevice)
{
MyFunction(i);
}
}
}
If you need communication between coprocessors, this is more complex. You can indirectly communicate between coprocessors by passing messages to/from host, but this would require synchronization at communication. This is where MPI would be a good tool.
We have a comprehensive free Web-based training coming soon where you can learn more: http://colfaxresearch.com/how-series/
