introduccion - openmp pdf
omp paralelo vs. omp paralelo para (5)
Aquí hay un ejemplo del uso de parallel separado y for here . En resumen, se puede usar para la asignación dinámica de matrices OpenMP thread-private antes de ejecutar for ciclo en varios hilos. Es imposible hacer la misma inicialización en parallel for caso.
UPD: en el ejemplo de la pregunta, no hay diferencia entre pragma simple y dos pragmas. Pero en la práctica puede realizar un comportamiento más atento a los subprocesos con paralelo separado y para las directivas. Algunos códigos, por ejemplo:
#pragma omp parallel
{
double *data = (double*)malloc(...); // this data is thread private
#pragma omp for
for(1...100) // first parallelized cycle
{
}
#pragma omp single
{} // make some single thread processing
#pragma omp for // second parallelized cycle
for(1...100)
{
}
#pragma omp single
{} // make some single thread processing again
free(data); // free thread private data
}
¿Cuál es la diferencia entre estos dos?
[UN]
#pragma omp parallel
{
#pragma omp for
for(int i = 1; i < 100; ++i)
{
...
}
}
[SEGUNDO]
#pragma omp parallel for
for(int i = 1; i < 100; ++i)
{
...
}
Aunque ambas versiones del ejemplo específico son equivalentes, como ya se mencionó en las otras respuestas, todavía hay una pequeña diferencia entre ellas. La primera versión incluye una barrera implícita innecesaria, que se encuentra al final de la "omp for". La otra barrera implícita se puede encontrar al final de la región paralela. Agregar "nowait" a "omp for" haría que los dos códigos fueran equivalentes, al menos desde una perspectiva OpenMP. Menciono esto porque un compilador OpenMP podría generar código ligeramente diferente para los dos casos.
Estos son equivalentes.
#pragma omp parallel genera un grupo de subprocesos, mientras que #pragma omp for divide las iteraciones de bucle entre los subprocesos generados. Puede hacer ambas cosas a la vez con la directiva fusionada #pragma omp parallel for .
Estoy viendo tiempos de ejecución totalmente diferentes cuando tomo un bucle en g ++ 4.7.0 y uso
std::vector<double> x;
std::vector<double> y;
std::vector<double> prod;
for (int i = 0; i < 5000000; i++)
{
double r1 = ((double)rand() / double(RAND_MAX)) * 5;
double r2 = ((double)rand() / double(RAND_MAX)) * 5;
x.push_back(r1);
y.push_back(r2);
}
int sz = x.size();
#pragma omp parallel for
for (int i = 0; i< sz; i++)
prod[i] = x[i] * y[i];
el código de serie (sin openmp ) se ejecuta en 79 ms. el código "paralelo para" se ejecuta en 29 ms. Si omito el y uso de #pragma omp parallel , el tiempo de ejecución se dispara a 179 ms, que es más lento que el código de serie. (la máquina tiene una concurrencia hw de 8)
el código se vincula a libgomp
No creo que haya ninguna diferencia, uno es un atajo para el otro. Aunque su implementación exacta podría tratarlos de manera diferente.
Las construcciones de trabajo compartido paralelas combinadas son un acceso directo para especificar una construcción paralela que contiene una construcción de trabajo compartido y ninguna otra instrucción. Las cláusulas permitidas son la unión de las cláusulas permitidas para las construcciones paralelas y de reparto de trabajo.
Tomado de http://www.openmp.org/mp-documents/OpenMP3.0-SummarySpec.pdf
Las especificaciones para OpenMP están aquí: