Linux Kernel Capítulo 3 – Escalonamento de Processos

Características principais do mecanismo de escalonamento do Linux: Visão Geral Características principais do mecanismo de escalonamento do Linux: Sistema operacional multitarefas; escalonamento preemptivo; utiliza 3 políticas de escalonamento: FIFO, Round-Robin e por Prioridade; prioridades calculadas dinamicamente; timeslice calculado dinamicamente; tratamento diferenciado para os processos do tipo “tempo-real”; kernel preemptivo.

Características principais do mecanismo de prioridades do Linux: Determinando Prioridades Características principais do mecanismo de prioridades do Linux: Duas escalas de prioridade distintas: nice values e real-time priorities; nice values: -20 a 19 real-time: 1 a MAX_RT_PRIO-1 = 99 tanto o usuário quanto o sistema influenciam na determinação das prioridades dos processos; procura beneficiar processos interativos (como??); task_struct.sleep_avg 0 ---- MAX_SLEEP_AVG = 10 ms; Real-time priorities implementadas de acordo com o padrão POSIX; 1 MAX_RT_PRIO MAX_RT_PRIO+40 real time nice values

Características principais do mecanismo de prioridades do Linux: Determinando Timeslices Características principais do mecanismo de prioridades do Linux: O timeslice destinado a cada processo é calculados com base na sua prioridade dinâmica; Mínimo 10 ms Default 100 ms Máximo 200 ms Maior prioridade ou maior interatividade Menor prioridade ou menor interatividade processos filhos ganham a metade do tempo restante no timeslice do seu pai;

O Algoritmo de Escalonamento Metas (alcançadas) para novo escalonador desenvolvido a partir da versão 2.5 do kernel: Garantir complexidade assintótica constante - O(1); implementar escalabilidade SMP (Symmetric Multiprocessing) perfeita; implementar afinidade SMP aprimorada; garantir boa interatividade; garantir justiça entre os processos; otimização para o caso comum onde existem apenas 1 ou 2 processos prontos para execução e ainda funcionar bem para múltiplos processadores cada um com vários processos.

O Algoritmo de Escalonamento Fila de expirados Fila de ativos Round n: Fila de expirados Fila de ativos Round n+1: Starvation??

O Algoritmo de Escalonamento struct runqueue { spinlock_t lock; /* spin lock which protects this runqueue */ unsigned long nr_running; /* number of runnable tasks */ unsigned long nr_switches; /* number of context switches */ unsigned long expired_timestamp; /* time of last array swap */ unsigned long nruninterruptible; /* number of tasks in uinterruptible sleep */ struct task_struct *curr; /* this processor’s currently running task */ struct task_struct *idle; /* this processor’s idle task */ struct mm_struct *prev_mm; /* mm_struct of last running task */ struct prio_array *active; /* pointer to the active priority array */ struct prio_array *expired; /* pointer to the expired priority array */ struct prio_array arrays[2]; /* the actual priority arrays */ int prev_cpu_load[NR_CPUS]; /* load on each processor */ struct task_struct *migration_thread; /* the migration thread on this processor */ struct list_head migration_queue; /* the migration queue for this processor */ atomic_t nr_iowait; /* number of tasks waiting on I/O*/ }

O Algoritmo de Escalonamento struct prio_array { unsigned int nr_active; /* number of taks */ unsigned long bitmap[BITMAP_SIZE]; /* priority bitmap */ struct list_head queue[MAX_PRIO]; /* priority queues */ }; struct list_head { struct list_head *next; /* ponteiro para o próximo nó da lista */ struct list_head *prev; /* ponteiro para o no anterior */

O Algoritmo de Escalonamento arrays[0] queue[0] = queue[1] = . . . . . . queue[MAX_PRIO] = active arrays[1] queue[0] = expired queue[1] = . . . . . . queue[MAX_PRIO] =

O Algoritmo de Escalonamento void schedule(){ struct task_struct *next; struct prio_array *array; struct list_head *queue; int idx; … array = rq->active; ... idx = sched_find_first_bit(array->bitmap); queue = array->queue + idx; next = list_entry(queue->next, task_t, run_list); prev = context_switch(rq, prev, next); }

Principais trabalhos realizados pela função context_swith() : O Algoritmo de Escalonamento Principais trabalhos realizados pela função context_swith() : Chaveamento do mapeamento da memória virtual do processo antigo para o novo processo: através de chamada a função switch_mm() (definida em include/asm/context.h) Salvamento e recuperação de dados de pilha e registradores: através de chamada a função swith_to() (definida em include/asm/system.h)

Privilegiando processos interativos sem starvation : O Algoritmo de Escalonamento Privilegiando processos interativos sem starvation : Função scheduler_tick(), chamada via interrupção de tempo (Capítulo 9): struct task_struct *task = current; struct runqueue *rq = this_rq(); If (! - - task->time_slice){ if ( ! TASK_INTERACTIVE(task) || EXPIRED_STARVING( rq ) ){ enqueue_task( task, rq->expired ); }else{ enqueue_task( task, rq->active ); }

Características principais do balanceamento de carga no Linux: Implementado em kernel/sched.c na função load_balance(); É chamada por schedule() quando a runqueue corrente está vazia ou pelo temporizador do sistema. Em sistemas monoprocessados, nem sequer é compilada com o kernel. Algoritmo: Encontra a runqueue mais ocupada. Se não existe nenhuma runqueue com pelo menos 25% a mais de carga do que a runqueue atual, termina. Decide qual priority array dentro da runqueue mais sobrecarregada será escolhido. O expired é o mais indicado. Por quê? Escolhe a fila de processos de maior prioridade. Por quê? Cada processo desta prioridade é analisado. São escolhidos os melhores. Quais??? Enquanto houver filas desbalanceadas, repete passo 1.

Perguntas??? ? ? ? ? ? ? ?