El algoritmo parallel_for

El Concurrency:: parallel_for algoritmo realiza repetidamente la misma tarea en paralelo. Cada una de
estas tareas se parametriza por un valor de la iteración. Este algoritmo es útil cuando tiene un cuerpo
de bucle que no comparte recursos entre las iteraciones del bucle.
El parallel_for algoritmo divide las tareas de forma óptima para la ejecución en paralelo. Utiliza un
algoritmo y robo para equilibrar estas particiones cuando las cargas de trabajo están desequilibradas
de intervalo de robo de trabajo. Cuando una iteración del bucle se bloquea de forma cooperativa, el
tiempo de ejecución redistribuye el intervalo de iteraciones que se asigna al subproceso actual a otros
subprocesos o procesadores. De forma similar, cuando un subproceso finaliza un intervalo de
iteraciones, el tiempo de ejecución redistribuye el trabajo de otros subprocesos a ese subproceso. El
parallel_for también es compatible con el algoritmo anidados paralelismo. Cuando un bucle paralelo
contiene otro bucle paralelo, el tiempo de ejecución coordina los recursos de procesamiento entre los
cuerpos de bucle de manera eficaz para la ejecución en paralelo.
El parallel_for algoritmo tiene varias versiones sobrecargadas. La primera versión toma un valor
inicial, un valor final y una función de trabajo (una expresión lambda, objeto de función o puntero a
función). La segunda versión toma un valor inicial, un valor final, un valor mediante el cual paso y una
función de trabajo. La primera versión de esta función usa 1 como el valor de incremento. Las versiones
restantes toman objetos de particionador, que le permiten especificar cómo parallel_for debería
crear particiones de intervalos entre subprocesos. Particionadores se explican con más detalle en la
sección particiones trabajo en este documento.
Puede convertir muchos for bucles usar parallel_for. Sin embargo, la parallel_for algoritmo difiere
de la for instrucción de las maneras siguientes:
 El parallel_for algoritmo parallel_for no se ejecutarán las tareas en un orden
predeterminado.
 El parallel_for algoritmo no admite condiciones de finalización arbitrarias. El parallel_for
algoritmo se detiene cuando el valor actual de la variable de iteración es uno menos de last.
 El _Index_type parámetro de tipo debe ser un tipo entero. Este tipo entero puede ser con o sin
signo.
 La iteración del bucle debe ser hacia delante. El parallel_for algoritmo produce una
excepción de tipo std::invalid_argument Si el _Step del parámetro es menor que 1.
 El mecanismo de control de excepciones para el parallel_for algoritmo difiere de un for
bucle. Si varias excepciones se producen simultáneamente en el cuerpo de un bucle paralelo, el
tiempo de ejecución propaga sólo una de las excepciones en el subproceso que llamó a
parallel_for. Además, cuando una iteración del bucle, produce una excepción, el tiempo de
ejecución no detiene inmediatamente el bucle general. En su lugar, el bucle se coloca en el
estado cancelado y el runtime descarta cualquier tarea que no se ha iniciado todavía. Para
obtener más información acerca de los algoritmos paralelos y de control de excepciones, vea
Exception Handling.
Aunque el parallel_for algoritmo no admite condiciones de finalización arbitrarias, puede usar la
cancelación para detener todas las tareas. Para obtener más información sobre la cancelación, consulte
cancelación.

Nota
El costo de programación que los resultados de equilibrio de carga y la compatibilidad con
características como la cancelación no pueden superar las ventajas de ejecutar el cuerpo del bucle en
paralelo, especialmente cuando el cuerpo del bucle es relativamente pequeño. Puede reducir esta
sobrecarga utilizando un particionador en el bucle paralelo. Para obtener más información, consulte
trabajo particiones más adelante en este documento.
Ejemplo
En el ejemplo siguiente se muestra la estructura básica de la parallel_for algoritmo. En este ejemplo
se imprime en la consola cada valor en el intervalo [1, 5] en paralelo.

// parallel-for-structure.cpp
// compile with: /EHsc
#include <ppl.h>
#include <array>
#include <sstream>
#include <iostream>

using namespace concurrency;

using namespace std;

int wmain()
{
// Print each value from 1 to 5 in parallel.
parallel_for(1, 6, [](int value) {
wstringstream ss;
ss << value << L' ';
wcout << ss.str();
});
}

Salida:
1 2 4 3 5

Dado que el parallel_for algoritmo actúa en cada elemento en paralelo, variará el orden en que los
valores se imprimen en la consola.
Para obtener un ejemplo completo que usa el parallel_for algoritmo, vea Cómo: escribir un bucle
parallel_for.

El algoritmo parallel_for_each
El Concurrency:: parallel_for_each algoritmo realiza tareas en un contenedor iterativo, como los que
proporciona STL, en paralelo. Usa la misma lógica de creación de particiones que el algoritmo
parallel_for.
El parallel_for_each algoritmo es similar a la STL std:: for_each algoritmo, salvo que el
parallel_for_each algoritmo ejecuta las tareas de forma simultánea. Al igual que otros algoritmos
paralelos, parallel_for_each no ejecuta las tareas en un orden específico.
Aunque el parallel_for_each algoritmo funciona en iteradores hacia delante e iteradores de acceso
aleatorio, funciona mejor con iteradores de acceso aleatorio.
Ejemplo
En el ejemplo siguiente se muestra la estructura básica de la parallel_for_each algoritmo. En este
ejemplo se imprime en la consola cada valor en una std:: Array objeto en paralelo.

// parallel-for-each-structure.cpp
// compile with: /EHsc
#include <ppl.h>
#include <array>
#include <sstream>
#include <iostream>

using namespace concurrency;

using namespace std;

int wmain()
{
// Create an array of integer values.
array<int, 5> values = { 1, 2, 3, 4, 5 };

// Print each value in the array in parallel.

parallel_for_each(begin(values), end(values), [](int value) {
wstringstream ss;
ss << value << L' ';
wcout << ss.str();
});
}
/* Sample output:
5 4 3 1 2
*/