Access to the task pool must be synchronized to avoid race conditions. Using a task-based execution, the execution of a parallel program is finished, when the task pool is empty and when each thread has terminated the processing of its last task. Task pools provide a flexible execution scheme which is especially useful for adaptive and irregular applications for which the computations to be performed are not fixed at program start. Since a fixed number of threads is used, the overhead for thread creation is independent of the problem size and the number of tasks to be processed. Flexibility is ensured, since tasks can be generated dynamically at any point during program execution. The actual task pool data structure could be provided bythe programming environment used or could be included in the parallel program. An example for the first case is the Executor interface of Java, see Sect. 6.2 for more details. A simple task pool implementation based on a shared data structure is described in Sect. 6.1.6 using Pthreads. For fine grained tasks, the overhead of retrieval and insertion of tasks from or into the task pool becomes important, and sophisticated data structures should be used for the implementation, see [93] for more details. 3.3.6.9 Producer–Consumer The producer–consumer model distinguishes between producer threads and consumer threads. Producer threads produce data which are used as input by consumer threads. For the transfer of data from producer threads to consumer threads, a common data structure is used, which is typically a data buffer of fixed length and which can be accessed by both types of threads. Producer threads store the data elements generated into the buffer, consumer threads retrieve data elements from the buffer for further processing, see Fig. 3.6 (right) for an illustration. A producer thread can only store data elements into the buffer, if this is not full. A consumer thread can only retrieve data elements from the buffer, if this is not empty. Therefore, synchronization has to be used to ensure a correct coordination between producer and consumer threads. The producer–consumer model is considered in more detail in Sect. 6.1.9 for Pthreads and Sect. 6.2.3 for Java threads.

El acceso al grupo de tareas debe estar sincronizado para evitar condiciones de carrera. Al utilizar una ejecución basada en tareas, la ejecución de un programa paralelo finaliza, cuando el grupo de tareas está vacío y cada subproceso ha finalizado el procesamiento de su última tarea. Los grupos de tareas proporcionan un esquema de ejecución flexible que es especialmente útil para aplicaciones adaptables e irregulares para las cuales los cálculos a realizar no se fijan al inicio del programa. Dado que se utiliza un número fijo de subprocesos, la sobrecarga para la creación de subprocesos es independiente del tamaño del problema y del número de tareas a procesar. La flexibilidad está asegurada, ya que las tareas se pueden generar dinámicamente en cualquier momento durante la ejecución del programa. La estructura de datos del grupo de tareas real podría ser proporcionada por el entorno de programación usado o podría incluirse en el programa paralelo. Un ejemplo para el primer caso es la interfaz Executor de Java, ver Sect. 6.2 para más detalles. Una implementación de grupo de tareas simple basada en una estructura de datos compartida se describe en la Sect. 6.1.6 utilizando Pthreads. Para tareas detalladas, la sobrecarga de recuperación e inserción de tareas desde o hacia el grupo de tareas se vuelve importante, y se deben usar estructuras de datos sofisticadas para la implementación, consulte [93] para obtener más detalles. 3.3.6.9 Productor – Consumidor El modelo productor-consumidor distingue entre hilos productores e hilos consumidores. Los subprocesos del productor producen datos que se utilizan como entrada por los subprocesos del consumidor.Para la transferencia de datos de subprocesos de producción a subprocesos de consumo, se utiliza una estructura de datos común, que suele ser un búfer de datos de longitud fija y al que se puede acceder mediante ambos tipos de subprocesos. Los subprocesos del productor almacenan los elementos de datos generados en el búfer, los subprocesos del consumidor recuperan los elementos de datos del búfer para un procesamiento adicional; consulte la Fig. 3.6 (derecha) para ver una ilustración. Un hilo productor solo puede almacenar elementos de datos en el búfer, si no está lleno. Un subproceso de consumidor solo puede recuperar elementos de datos del búfer, si esto no está vacío. Por lo tanto, la sincronización se debe utilizar para garantizar una coordinación correcta entre las hebras productor y consumidor. El modelo productor-consumidor se considera con más detalle en la Sección. 6.1.9 para Pthreads y Sect. 6.2.3 para hilos de Java.