PDF de programación - Programación Concurrente - Bloque II: Programación concurrente en POSIX - Tema 5. Planificación de Threads

Master en Computación

Programación Concurrente

Bloque II: Programación concurrente en POSIX

Introducción al estándar POSIX

Tema 1.
Tema 2. Sistema Operativo MaRTE OS
Tema 3. Gestión de Threads
Tema 4. Gestión del Tiempo

Tema 5. Planificación de Threads

Tema 6. Sincronización
Tema 7. Señales
Tema 8. Temporizadores y Relojes de Tiempo de Ejecución

Programación Concurrente

Tema 5. Planificación de Threads

© M. Aldea, M. González

oct-13



1



Introducción

Tema 5. Planificación de Threads
5.1.
5.2. Políticas de planificación
5.3.
5.4. Ejemplo: planificación de threads
5.5.

Interfaz para la planificación de threads

Implementación de la cola de tareas ejecutables en MaRTE
OS

Programación Concurrente

Tema 5. Planificación de Threads

© M. Aldea, M. González

oct-13

2

5.1 Introducción

5.1 Introducción
Un thread puede estar en tres estados diferentes:

• en ejecución: está en ejecución en un procesador
• activo: está listo para ejecutar, pero aún no tiene un procesador

disponible

• bloqueado o suspendido: esperando a una condición para

poder continuar ejecutando

en ejecución

suspensión

expulsión

planificación

bloqueado

activo

a ctiv a ció n

Programación Concurrente

© M. Aldea, M. González

oct-13

3

Tema 5. Planificación de Threads

Conceptos básicos
Prioridad:

5.1 Introducción

• Número entero positivo asociado a cada thread (o proceso) y

utilizado por la política de planificación

Política de Planificación:

• Conjunto de reglas para determinar el orden de ejecución de los

threads (o procesos)

• Afecta a la ordenación de los threads (o procesos) cuando:

- se suspenden, bloquean o son expulsados
- se activan
- llaman a una función que cambia la prioridad o la política

• Conceptualmente podemos considerar que existe una cola de

threads activos por cada nivel de prioridad
- y un thread ejecutando (fuera de la cola) por cada procesador

Programación Concurrente

Tema 5. Planificación de Threads

© M. Aldea, M. González

oct-13

4

5.2 Políticas de planificación

5.2 Políticas de planificación
• SCHED_FIFO: planificación expulsora por prioridad, con orden
FIFO para la misma prioridad
• SCHED_RR: planificación expulsora por prioridad, con orden
rotatorio para la misma prioridad; la rodaja temporal es fija
• SCHED_SPORADIC: planificación de servidor esporádico
• SCHED_OTHER: otra política de planificación por prioridad,
dependiente de la implementación

I

O
F
F
_
D
E
H
C
S

o

R
R
_
D
E
H
C
S

T1 (T=8, C=2)

T2 (T=13, C=5)

T3 (T=14, C=3)

Programación Concurrente

Tema 5. Planificación de Threads

© M. Aldea, M. González

oct-13

5

5.2 Políticas de planificación

Política de servidor esporádico
Para procesar actividades aperiódicas a la prioridad deseada, con:

- respuesta rápida a eventos
- efectos predecibles sobre tareas de prioridad inferior, incluso

para ritmos de llegada no acotados

Es una política de reserva de anchura de banda del procesador:
- el tiempo de ejecución se limita a la capacidad de ejecución
- la capacidad se rellena después de un periodo de relleno

T_SS (T=7, C=3)

T_SS prio. alta

T_SS prio. baja

T_SS Capacidad

relleno de 2

Programación Concurrente

relleno de 1

relleno de 1
© M. Aldea, M. González

oct-13

relleno de 2

6

Tema 5. Planificación de Threads

5.3 Interfaz para la planificación de threads

5.3 Interfaz para la planificación de threads
Atributos de planificación:

• Son parte del objeto de atributos que se utiliza al crear el thread
• Ámbito de contención (“contentionscope”); valores:
• ámbito de sistema: PTHREAD_SCOPE_SYSTEM
• ámbito de proceso: PTHREAD_SCOPE_PROCESS
• Herencia de atributos de planificación (“inheritsched”); muy
importante, ya que si hay herencia no se hace caso del resto de
atributos de planificación; valores:
• hereda los del padre: PTHREAD_INHERIT_SCHED
• usa los del objeto attr: PTHREAD_EXPLICIT_SCHED
- valor por defecto en MaRTE OS
- no tiene porqué ser el valor por defecto en otros SOs POSIX

Programación Concurrente

Tema 5. Planificación de Threads

© M. Aldea, M. González

oct-13

5.3 Interfaz para la planificación de threads

Atributos de planificación
• Política de planificación (“schedpolicy”); valores:
• SCHED_FIFO, SCHED_RR, SCHED_SPORADIC y SCHED_OTHER
• Parámetros de planificación (“schedparam”):

(cont.)

7

8

9

#include <sched.h>
#include <time.h>
struct sched_param {

int sched_priority;
int sched_ss_low_priority;
struct timespec sched_ss_repl_period;
struct timespec sched_ss_init_budget;
int sched_ss_max_repl;

}
• Los cuatro últimos campos sólo se usan en la política de

servidor esporádico

Programación Concurrente

Tema 5. Planificación de Threads

© M. Aldea, M. González

oct-13

5.3 Interfaz para la planificación de threads

Funciones para atributos de planificación
#include <pthread.h>
int pthread_attr_getscope (const pthread_attr_t *attr,
int *contentionscope);
int pthread_attr_setscope (pthread_attr_t *attr,
int contentionscope);

PTHREAD_SCOPE_SYSTEM
PTHREAD_SCOPE_PROCESS

int pthread_attr_getinheritsched (const pthread_attr_t *attr,
int *inheritsched);
int pthread_attr_setinheritsched (pthread_attr_t *attr,
int inheritsched);

PTHREAD_INHERIT_SCHED
PTHREAD_EXPLICIT_SCHED

Programación Concurrente

© M. Aldea, M. González

oct-13

Tema 5. Planificación de Threads

5.3 Interfaz para la planificación de threads

Funciones para atributos de planificación(cont.)
int pthread_attr_getschedpolicy (const pthread_attr_t *attr,
int *policy);
int pthread_attr_setschedpolicy (pthread_attr_t *attr,
int policy);

SCHED_FIFO
SCHED_RR
SCHED_SPORADIC
SCHED_OTHER

int pthread_attr_getschedparam (const pthread_attr_t *attr,
struct sched_param *param);
int pthread_attr_setschedparam (pthread_attr_t *attr,
const struct sched_param *param);

struct sched_param {

int sched_priority;
int sched_ss_low_priority;
struct timespec sched_ss_repl_period;
struct timespec sched_ss_init_budget;
int sched_ss_max_repl;

}

En MaRTE OS, si no se especifican atributos de planificación:
- política por defecto: SCHED_FIFO
- prioridad por defecto: intermedia para el thread main, 0 para los demás

© M. Aldea, M. González

oct-13

10

Programación Concurrente

Tema 5. Planificación de Threads

5.3 Interfaz para la planificación de threads

Cambio dinámico de atributos de planificación
#include <pthread.h>
int pthread_getschedparam (pthread_t thread,
int *policy,
struct sched_param *param);
int pthread_setschedparam (pthread_t thread,
int policy,
const struct sched_param *param);

SCHED_FIFO
SCHED_RR
SCHED_SPORADIC
SCHED_OTHER

struct sched_param {

int sched_priority;
int sched_ss_low_priority;
struct timespec sched_ss_repl_period;
struct timespec sched_ss_init_budget;
int sched_ss_max_repl;

}

int pthread_setschedprio(pthread_t thread, int prio);

Programación Concurrente

Tema 5. Planificación de Threads

© M. Aldea, M. González

oct-13

11

5.3 Interfaz para la planificación de threads

Cambio dinámico de atributos de planificación (cont.)

El comportamiento de pthread_setschedparam() y de
pthread_setschedprio() es diferente cuando se baja la
prioridad del thread
• pthread_setschedparam():
T2

cola de prio. 10

T4

T1

T3

T5

cola de prio. 8

T6
• pthread_setschedprio():
T2

cola de prio. 10

T4

cola de prio. 8

T1

T5

baja la prioridad
de t1 de 10 a 8

T1

T3

T1
baja la prioridad
de t1 de 10 a 8
T6

Programación Concurrente

© M. Aldea, M. González

oct-13

12

Tema 5. Planificación de Threads

Otras funciones

Ceder el procesador:

int sched_yield (void);

5.3 Interfaz para la planificación de threads

Leer los límites de los parámetros:

int sched_get_priority_max(int policy);
int sched_get_priority_min(int policy);
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval);

Rodaja temporal en MaRTE OS: 0.03 seg.

© M. Aldea, M. González

oct-13

13

5.4 Ejemplo: planificación de threads

Programación Concurrente

Tema 5. Planificación de Threads

5.4 Ejemplo: planificación de threads
"Come-tiempos" (include/misc/load.h):
//////////////////////////////////////////////////////
/// LOAD.H ///
//////////////////////////////////////////////////////
// La función eat() permite consumir el tiempo //
// de CPU indicado por for_seconds //
//
// La función adjust() debe ser llamada una vez //
// antes de llamar a eat(). No es necesario //
// llamarla posteriormente. //
void eat (float for_seconds);
void adjust (void);

Programación Concurrente

Tema 5. Planificación de Threads

© M. Aldea, M. González

oct-13

14

5.4 Ejemplo: planificación de threads
Ejemplo: planificación de threads (cont.)

// Programa principal
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
#include <misc/error_checks.h>
#include <misc/timespec_operations.h>
#include <misc/load.h>
// datos transferidos a cada thread como argumento
struct thread_params {
float execution_time;
struct timespec period;
int id; // identificador de la tarea
};

Programación Concurrente

© M. Aldea, M. González

oct-13

15

Tema 5. Planificación de Threads

5.4 Ejemplo: planificación de threads
Ejemplo: planificación de threads (cont.)

// Thread periódico
// Pone un mensaje en pantalla, consume tiempo de CPU,
// y pone otro mensaje
void * periodic (void *arg) {
struct thread_params params = *(struct thread_params*)arg;
struct timespec next_time;
// lee la hora de la primera activación de la tarea
clock_gettime(CLOCK_MONOTONIC, &next_time);
// lazo que se ejecuta periódicamente
while (1) {
printf("Thread %d empieza \n",par