Академический Документы
Профессиональный Документы
Культура Документы
Projeto 2
Tema D: Escalonamento de processos no
MINIX3
Autores:
Jun Miyazaki
Leonardo Elias de Souza Oliveira
Lucas Martins De Marchi
Lus Gustavo Ludescher
Lus Felipe Lu
Marcelo Trevizan Mazon
Objetivo
O objetivo deste projeto continuar o estudo do cdigo fonte do MINIX3 iniciado no Projeto
1, como complementao da disciplina terica PCS 2042 Sistemas Operacionais.
Para a determinao da prioridade que deve ser atribuda a um processo, ou seja, em qual das
filas de prioridade o mesmo deve ser colocado, a funo sched verifica se o mesmo ainda
tem tempo de execuo, ou seja, se ele ainda no consumiu todo o quantum que lhe
atribudo. Caso no haja, ele recebe um novo quantum e uma menor prioridade (ou seja, um
ndice maior nas filas de prioridades). A varivel que guarda o tempo restante, time_left,
tambm usada para indicar se o processo deve ser posicionado no comeo ou no fim da fila,
de acordo com o parmetro de retorno front. Caso haja tempo sobrando, deve ir para o
incio da fila para ser executado primeiro. Se no, colocado no fim da fila de sua prioridade.
/*===========================================================================*
* sched *
*===========================================================================*/
PRIVATE void sched(rp, queue, front)
register struct proc *rp; /* process to be scheduled */
int *queue; /* return: queue to use */
int *front; /* return: front or back */
{
/* This function determines the scheduling policy. It is called whenever a
* process must be added to one of the scheduling queues to decide where to
* insert it. As a side-effect the process' priority may be updated.
*/
int time_left = (rp->p_ticks_left > 0); /* quantum fully consumed */
/* Check whether the process has time left. Otherwise give a new quantum
* and lower the process priority, unless the process already is in the
* lowest queue.
*/
if ( ! time_left) { /* quantum consumed ? */
rp->p_ticks_left = rp->p_quantum_size; /* give new quantum */
if (rp->p_priority < (IDLE_Q-1)) (
rp->p_priority += 1; /* lower priority */
}
}
/* If there is time left, the process is added to the front of its queue,
* so that it can immediately run. The queue to use simply is always the
* process' current priority.
*/
*queue = rp->p_priority;
*front = time_left;
}
Na funo pick_proc o processo no incio da fila de maior prioridade (menor ndice) no-
vazia escolhido. Trata-se de um iterador que comea pela fila de ndice 0, at que seja
encontrado um processo. Se no houver nenhum disponvel, entra-se na fila de IDLE.
/*===========================================================================*
* pick_proc *
*===========================================================================*/
PRIVATE void pick_proc()
{
/* Decide who to run now. A new process is selected by setting 'next_ptr'.
* When a billable process is selected, record it in 'bill_ptr', so that the
* clock task can tell who to bill for system time.
*/
register struct proc *rp; /* process to run */
int q; /* iterate over queues */
/* Check each of the scheduling queues for ready processes. The number of
* queues is defined in proc.h, and priorities are set in the image table.
* The lowest queue contains IDLE, which is always ready.
*/
for (q=0; q < NR_SCHED_QUEUES; q++) {
if ( (rp = rdy_head[q]) != NIL_PROC) {
next_ptr = rp; /* run process 'rp' next */
if (priv(rp)->s_flags & BILLABLE)
bill_ptr = rp; /* bill for system time */
return;
}
}
}
Alterao do cdigo
Props-se alterar o cdigo do MINIX3 a fim de mudar a sua poltica de escalonamento para o
agendamento por sorteio. Em linhas gerais, esse mtodo distribui bilhetes para os
processos em quantidades que variam de acordo com prioridades, tempos de execuo
conhecidos ou estimados, entre outros. Quando deve-se executar um processo, sorteia-se um
bilhete, sendo que processos com maior nmero de bilhetes tm maior probabilidade de
serem sorteados.
Para a distribuio de bilhetes, ainda leva-se em conta a prioridade do processo, de modo que
processos com maior prioridade ganham maior nmero de bilhetes. definido o nmero de
bilhetes para cada fila de prioridade i (n_tickets_i = (16 - prioridade_i) * n_processos_i).
Somam-se os valores de todas as filas, e faz-se um sorteio de 1 at o resultado da soma.
Percorrem-se os nveis at encontrar a fila a que pertence o nmero sorteado (subtraindo o
nmero sorteado de n_tickets_i), e identifica-se o processo da fila que foi sorteado (dividindo
o nmero sorteado pelo nmero de bilhetes de cada processo da fila).
A ltima fila, a de IDLE, no entra no sorteio, pois s deve ser acionada quando no houver
outros processos nas filas.
intnumrandom,tickets,i;
/*Checkeachoftheschedulingqueuesforreadyprocesses.Thenumberof
*queuesisdefinedinproc.h,andprioritiesaresetinthetasktable.
*ThelowestqueuecontainsIDLE,whichisalwaysready.
*/
/*Sumoftickets.Iterateintonumber_of_process_per_queuevector*/
for(q=0,tickets=0;q<NR_SCHED_QUEUES1;q++)
tickets+=(nr_procs_rdy[q]*(NR_SCHED_QUEUES1q));
/*Ifnoprocessesar*/
if(tickets==0)
rp=rdy_head[NR_SCHED_QUEUES1];
else{
numrandom=(rand()%(tickets1))+1;
/*numrandom=tickets/2;*/
for(q=0;q<NR_SCHED_QUEUES1;q++){
tickets=(nr_procs_rdy[q]*(NR_SCHED_QUEUES1q));
if(numrandom<=tickets){
rp=rdy_head[q];
if(numrandom%(NR_SCHED_QUEUES1q)==0)i=1;
elsei=0;
for(;(rp!=NIL_PROC)&&(i<((int)(numrandom/(NR_SCHED_QUEUES1q))));i++)
rp=rp>p_nextready;
}
else
numrandom=tickets;
}
}
if(rp!=NIL_PROC){
next_ptr=rp;
if(priv(rp)>s_flags&BILLABLE)
bill_ptr=rp;
return;
}
elsekprintf("erroinesperado....rp==NIL_PROC");
}