Artigo Sobre Escalonamento de Processos

BCC34G Sistemas Operacionais
Processos
Processos
Aline Rocha Leo, Renan Felipe Toshiaki Bieszczad Ikeda
Universidade Tecnolgica Federal do Paran UTFPR
COCIC Coordenao do Curso de Bacharelado em Cincia da Computao
Campo Mouro, Paran, Brasil
aline05_leao@hotmail.com
renanikeda@gmail.com
O modelo de processo pode ser compreendido

mais facilmente ao se observar a figura 1.
Resumo
O artigo a seguir apresenta todas as caractersticas
dos processos, assim como a teoria relacionada a
forma com que eles so gerenciados pelo Sistema
Operacional (SO) e tambm o relatrio referente ao
projeto do simulador de escalonamento que foi
desenvolvido.
Figura 1 - Modelo de Processo

1. Introduo
Em um sistema multiprogramado a CPU alterna

entre os programas que se encontram em execuo.
Isso causa a impresso de paralelismo, ou seja, que
vrios programas esto sendo executados ao mesmo
tempo. Entretanto no bem isso que acontece, na
realidade, a CPU alterna entre os programas,
executando cada um deles por um intervalo de tempo
muito pequeno, na casa dos milissegundos. Essa
maneira de execuo pode ser denominada de
pseudoparalelismo, pois o paralelismo real existe nos
sistemas multiprocessadores. Um modelo conceitual,
desenvolvido nos ltimos anos e que leva o nome de
processos sequenciais, tem facilitado o paralelismo.
Na Figura 1-a, podem-se observar quatro

programas alocados na memria de um computador
multiprogramado. A Figura 1-b mostra os 4 processos,
cada qual com seu contador de programas independente
(contador lgico). Existe apenas um contador de
programas fsico (real), o valor desse contador varia de
acordo com o processo em execuo, ou seja, o
contador de programas lgico do processo carregado
no real. Quando termina o tempo de execuo do
processo, o valor do contador real gravado no
contador lgico, isso ocorre para que se possa
identificar onde o processo parou de executar. A Figura
1-c mostra que em um intervalo de tempo
suficientemente longo, vrios processos avanam,
porm se observar um instante de tempo pequeno,
apenas um processo avana por vez.
Devido ao chaveamento rpido da CPU, a taxa na
qual o processo realiza a sua computao no ser
uniforme e nem reproduzvel, ainda que um mesmo
processo seja executado novamente.
Um processo nada mais do que um conjunto de
elementos que so agrupados para que um programa
seja executado e por isso um processo diferente de
um programa. Um processo possui o programa
(algoritmo), entrada e sada e um estado de execuo.
Um processador pode ser compartilhado por diversos
processos, com algum algoritmo de escalonamento que
utilizado para se determinar quando parar o trabalho
sobre um processo e servir outro.
2.1 O modelo de processo
2.2 Criao de processos
Os processos so a abstrao mais importante que o

SO pode oferecer. Os processos permitem que apenas
um processador seja compartilhado por diversas
aplicaes. Basicamente, os processos transformam
uma nica CPU em diversas CPU's virtuais.
Este artigo dividido em algumas sees,
inicialmente (item 2) os processos e todas as suas
caractersticas so explicadas, posteriormente (item 3),
o escalonamento de processos explicado e por ltimo
(item 4), o simulador de escalonamento desenvolvido
foi descrito de maneira detalhada.
2. Processos
Processos
Para que um processo seja criado, preciso que

acontea algum dos seguintes eventos: inicializao do
sistema, execuo de uma chamada de sistema de
criao de processo por um processo em execuo,
requisio do usurio para criar um novo processo ou a
inicializao de uma tarefa em lotes.
Quando um sistema iniciado, diversos processos
podem ser inicializados com ele, esses processos
podem estar em foreground (primeiro plano), ou ento
em background (segundo plano), os processos em
primeiro plano so aqueles que interagem com o
usurio, j os que ficam em segundo plano so aqueles
que esto ligados a determinadas atividades do sistema,
como um cliente de e-mail, impressora, etc. Esses
processos em segundo plano tambm podem ser
chamados de daemons.
No UNIX existe uma chamada de sistema (system
call) chamada fork, a qual cria um clone idntico ao
processo que a chamou, inclusive com a mesma
imagem de memria, as mesmas variveis de ambiente
e os mesmos programas abertos. Posteriormente esse
clone executa outras chamadas para mudar sua posio
de memoria e executar um novo programa. No
Windows existe apenas a chamada CreateProcess, a
qual trata tanto da criao do processo, quanto da carga
do programa novo a ser executado.
mostrada para que haja uma nova tentativa e o processo

continua.
Cancelamento por um outro processo: Esse tipo de
sada tambm descrita como involuntria. Esse caso
ocorre quando um processo solicita ao sistema para que
este finalize um outro processo. No UNIX a chamada
para isto a kill.
2.5 Estados de processos

Um processo pode ter 3 estados: em execuo, que
quando o processo realmente esta utilizando a CPU;
pronto, que quando o processo pode ser executado,
mas est parado temporariamente para dar lugar a outro
processo e bloqueado, que quando o processo esta
aguardando algum evento externo para voltar a sua
execuo. Na Figura 2 possvel observar esses
estados e as transies que podem ocorrer entre eles.
2.3 Trmino de processos

Aps a criao do processo, ele executado e mais
tarde, por algum motivo ou outro ele deve ser
finalizado.
As razes para o seu trmino podem ser descritas
por quatro condies, e so elas:
Sada normal: Esse tipo de sada pode ser descrita
como voluntria. Esse caso ocorre quando o processo
consegue terminar seu trabalho normalmente e assim
efetuar uma chamada do sistema para que o processo
termine. No UNIX essa chamada a exit e exitProcess
no Windows.
Sada por erro: Esse tipo de sada tambm pode ser
descrita como voluntria. Esse caso ocorre quando h
um erro no processo, normalmente no programa que
est sendo executado. Dentre os exemplos em que pode
acontecer esse tipo de sada est: execuo de uma
instruo ilegal, diviso por zero ou memria
inexistente. Em alguns sistemas os processos no so
finalizados, mas sim sinalizados, pois o processo
solicita ao sistema que o deixe tratar de certos erros.
Sada por erro fatal: Esse tipo de sada descrita
como involuntria. Esse caso ocorre, quando, por
exemplo, digitado um nome de arquivo inexistente
para a compilao de um outro arquivo. Quando isso
ocorre, o processo finalizado. Quando o processo
possui base em uma tela, uma mensagem de erro
Figura 2 - Estados do processo

A transio 1 ocorre quando o SO descobre que um
processo no pode prosseguir. As transies 2 e 3 so
causadas pelo escalonador de processos, que uma
parte do SO, sem que o processo saiba disso. A
transio 4 ocorre quando acontece um evento externo
pelo qual o processo estava aguardando.
3. Escalonamento
Um escalonador a parte do sistema operacional
onde se faz a escolha de qual processo ser executado
em determinado momento. O escalonamento uma
operao relativamente simples nos sistemas em lote,
basicamente nesse tipo de sistema, o processo
executado de maneira sequencial, sem a necessidade da
ocorrncia dos chaveamentos. J os sistemas
multiprogramados, os algoritmos de escalonamento so
mais complexos, visto que existe concorrncia pelo uso
da CPU.
O escalonamento de suma importncia em
situaes onde o desempenho da CPU importante,
como em servidores por exemplo. Entretanto, nos
computadores pessoais, pode-se dizer que o
Processos
escalonamento no tem tanta importncia, devido ao

fato de que para o usurio comum, no importa qual
processo se inicia primeiro, o importante nesse caso
qual processo termina primeiro.
Para se fazer o escalonamento interessante que se
conhea sobre o comportamento dos processos, eles
podem ser limitados tanto pela CPU, quanto pelas
condies de E/S. Esse comportamento pode ser
observado mais claramente na Figura 3, onde na parte
(a) se encontram processos que so limitados pela CPU
e na parte (b) esto os processos limitados pela E/S.
de maior tempo. Utilizando esse algoritmo, a mdia de

realizao das tarefas ser menor, j que o tempo de
realizao de cada tarefa a soma de todas as tarefas
anteriores mais o seu tempo.
-Prximo do menor tempo restante:
Nesse algoritmo o tempo das tarefas tambm deve
ser conhecido, j que quando chega uma nova tarefa,
seu tempo de realizao calculado, e se este for
menor que o restante da tarefa em realizao, ento esta
ser suspensa e a nova tarefa ser feita.
-chaveamento circular:
Nesse algoritmo aplicado a cada processo um
intervalo de tempo, denominado quantum. Esse o
tempo permitido para o processo ser executado, assim
se o processo terminar nesse intervalo de tempo, a CPU
chaveada para outro processo, mas se o processo no
terminar durante o quantum, a CPU sofrer preempo
e ser fornecida a outro processo.
-Prioridades:
Nesse algoritmo, so selecionadas prioridades para
a realizao dos processos, assim o processo de mais
alta prioridade ser realizado primeiro.
-Filas mltiplas:
Nesse algoritmo, existem varias filas com
prioridades. Na primeira fila os processos de alta
prioridade recebem um certo quantum para ser
executado, se ao final do tempo ele no terminar, ele
passar para uma segunda fila. Nessa fila ele ter o
dobro do quantum e se, quando ele for executado
novamente, o tempo ainda no for o suficiente, ele
passar para uma terceira fila com um quantum 4 vezes
maior e assim por diante. Esse algoritmo usado para
um processo no ocupar muito tempo de execuo e
dar espao para outros.
-Escalonamento garantido:
O tempo destinado a cada processo deve ser
calculado pelo nmero de processos existentes, assim o
tempo destinado a cada um ser o mesmo.
-Escalonamento por loteria:
Os processos recebem bilhetes de loteria, sendo
que os prmios so recursos do sistema, como tempo
de CPU. Se o escalonamento for ocorrer, um bilhete
ser sorteado aleatoriamente e o processo que possuir
esse bilhete ser escalonado.
-Escalonamento por frao justa:
Uma frao da CPU alocada para cada usurio e o
escalonador escolhe os processos de modo que garanta
essa frao.
Figura 3 - Processos em surto de CPU e

limitados pela E/S
Com a evoluo das CPUs, os processos tendem a
ser limitados apenas pela E/S.
O escalonamento deve ocorrer todas as vezes em
que um processo for criado, terminado, bloqueado ou
sofrer alguma interrupo de E/S. Os algoritmos de
escalonamento podem ser de dois tipos, preemptivos,
que um algoritmo que escolhe um processo e deixa
ele executando na CPU por um tempo mximo fixado e
o no preemptivo, que um algoritmo que escolhe um
processo e deixa ele executando at que ele seja
bloqueado, ou at que ele libere a CPU de forma
voluntria.
Os algoritmos de escalonamento buscam alcanar
alguns objetivos dentro do sistema. Esses objetivos
esto listados na tabela 1 do anexo.
Existem 3 tipos de escalonamento, e so eles:
Escalonamento em sistemas interativos:
Escalonamento em lote:
-Primeiro a chegar, primeiro a ser servido

(FIFO):
Pode ser considerado o mais simples dos
algoritmos, onde basicamente criada uma fila nica
de processos. Assim, as tarefas so colocadas em uma
fila e so realizadas na ordem em que ficaram prontas.
Quando um processo em execuo bloqueado, ele
colocado ao final da fila e a prxima tarefa executada.
Esses algoritmos so fceis de programar, porm,
podem atrasar alguns processos importantes, devido a
sua caracterstica de fila nica.
-Tarefa mais curta primeiro (SJF):
Esse algoritmo aplicado quando o tempo de todas
as tarefas a serem realizadas conhecido, assim, elas
so realizadas a partir da tarefa de menor tempo para a
Escalonamento em sistemas de tempo real:
Existem dois tipos, o esttico, que quando a

deciso tomada antes de iniciar a execuo e o
Processos
int IN = 1;
if (procs == NULL){
printf("Erro ao abrir o arquivo
de testes");
return;
}
while(!feof(procs)){
prontos[i].id = i;
prontos[i].prioridade =
rand()%4; //define a prioridade de
forma aleatoria
prontos[i].tamJob = 0;
prontos[i].CP = 0;
prontos[i].tempoChegada = IN;
//definindo o tempo de chegada como a
variavel IN, que vai variar de 1 a 10
prontos[i].tempoEspera = 0;
prontos[i].tempoBloqMem = 0;
prontos[i].tempoBloqIO = 0;
fgets(prontos[i].bin,51,procs
); //lendo a sequencia de tarefas que
o processo pode executar e
armazenando em um vetor de char
i++;
IN++;
}
fclose(procs);
}
As informaes do arquivo foram armazenadas no
campo bin da struct. Os outros campos da struct foram
preenchidos com 0, com um valor aleatrio, como no
caso da prioridade, ou ento com uma varivel auxiliar
que era incrementada toda vez que existia uma quebra
de linha no arquivo. A varivel i foi utilizada para o
ndice do vetor e a varivel IN foi utilizada para
representar o tempo de chegada de cada processo no
vetor.
Com o vetor de bcp preenchido, iniciou-se a fase de
escalonar, a qual consistiu em ordenar os vetores de
acordo com o algoritmo desejado e aps isso, executar
o processo. O escalonamento foi feito atravs de 3
funes, cada uma delas para o tipo de algoritmo. O
prottipo das 3 funes pode ser observado a seguir e o
cdigo completo se encontra em anexo:
dinmico que quando a deciso tomada durante a

execuo.
4. Resultados
Desenvolvimento do simulador
Um software que simula o escalonamento de
processos foi desenvolvido na linguagem C e os
algoritmos desenvolvidos foram o FIFO, o SJF e o
Prioridade.
Inicialmente um BCP, que o bloco que controla os
processos foi modelado por meio de uma struct. Sua
estrutura pode ser visualizada no trecho de cdigo a
seguir:
struct bcp {
int id;
char bin[50]; //simulacao de uma
sequencia de eventos de processo (1 executando, 2-bloqueado para memoria,
3-bloqueado para IO
int prioridade; //varia de 0 a 3,
quanto menor for o numero, maior a
prioridade
int tamJob; //tamanho da tarefa
int CP; //contador de programa
int tempoChegada, tempoBloqMem,
tempoBloqIO, tempoEspera; //tempos do
processo
};
A partir dessa struct um vetor foi criado, o qual foi
utilizado para auxiliar a simulao do escalonador. Os
algoritmos escolhidos para essa simulao foram o
FIFO, que o algoritmo onde o primeiro processo que
chega, o primeiro que sai, o SJF, que consiste em
verificar qual processo possui o menor tempo de
execuo e a partir disso escolher a ordem de execuo
dos processos (nesse algoritmo os processos que
possuem o menor tempo so executados primeiro). O
outro algoritmo implementado foi o prioridade, que
consiste em executar os processos de acordo com a sua
prioridade, ou seja, os processos com prioridade maior
so executados primeiro.
O vetor foi preenchido com o auxlio de um
arquivo, o qual possui uma sequncia de caracteres (1,
2, 3 e 0), os quais correspondem a uma tarefa do
processo, o 1 corresponde a parte de execuo, o 2 a
parte de bloqueado para memria, o 3 para bloqueio de
IO e o 0 indica que o processo acabou a execuo. Uma
cpia se encontra em anexo. O preenchimento do vetor
se encontra no cdigo a seguir:
void carregaProcesso(string
nome_arq){
FILE *procs;
procs = fopen(nome_arq, "r");
int i = 0;
void FIFO (int n, BCP *prontos);

void PRIORIDADE (int n, BCP *prontos);
void SJF (int n, BCP *prontos)
A execuo foi feita atravs de uma anlise do vetor

bin que se encontra na struct. A seguir o prttipo da
funo utilizada pode ser observado e o cdigo
completo se encontra em anexo:
void executa(int
string LOG)
n,
BCP
*prontos,
Processos
Os parmetros utilizados, tanto nas funes de

escalonamento, quanto nas funes de execuo
correspondem ao tamanho do vetor (n), o vetor
(*prontos) e uma string que foi utilizada para gerar um
relatrio (LOG) do escalonamento escolhido. Este
ltimo parmetro foi utilizado apenas na parte de
execuo.
Para se executar o simulador, as funes so
chamadas no programa principal da seguinte maneira:
Para exemplificar esse fato, os dados do processo

com id 7, que possui prioridade 0, que conforme
descrito anteriormente um processo de alta
prioridade, podem ser observados na tabela 1:
Tabela 1 - quadro comparativo de tempos de

espera com id 7
Tipo de algoritmo
FIFO
SJF
Prioridade
int main(){
carregaProcesso("teste.txt");
PRIORIDADE(10, prontos);
FIFO(10, prontos);
SJF(10, prontos);
}
Onde o carregaProcesso busca preencher o vetor e
as outras fazem o escalonamento desejado e geram um
relatrio com algumas estatsticas.
Os relatrios gerados se encontram em anexo neste
trabalho, juntamente com todo o cdigo fonte do
simulador e tambm com o arquivo com as sequncias
de tarefas que foram utilizados para preencher o vetor
bin da struct bcp.
Estatsticas
Como foi uma simulao, todos os tempos foram
medidos em ciclos para facilitar a implementao e
tambm para que no houvesse impreciso nas medidas
que poderiam vir a acontecer devido a execuo do
simulador.
A fim de comparar o desempenho dos algoritmos,
algumas variveis foram medidas durante a execuo
do simulador, o tempo de espera total, o tempo de
espera de cada processo e o tempo de espera mdio.
Os dados individuais de cada processo podem ser
visualizados nos relatrios presentes no anexo deste
trabalho.
Em relao ao tempo total de espera, o algoritmo
que apresentou melhor desempenho foi o SJF, que nas
condies propostas (tarefas descritas no arquivo
testes.txt e explicadas anteriormente), teve um tempo
total de espera de 1410 ciclos, j o FIFO foi o segundo
melhor nesse quesito com tempo total de espera de
1430 ciclos e o Prioridade foi o que apresentou pior
desempenho, com 1470 ciclos. Consequentemente, na
mdia de tempo de espera de cada processo, a ordem de
desempenho foi a mesma.
Com essas anlises foi possvel verificar que o SJF
apresenta o melhor desempenho dentre os trs que
foram desenvolvidos, porm o prioridade que foi o pior
entre eles no necessariamente o pior, pois no
prioridade que os processos mais importantes so
executados primeiro e consequentemente diminuem o
seu tempo de espera, o que em alguns casos pode ser
essencial para que determinada tarefa seja realizada.
Tempo de Espera
221 ciclos
0
0
Pode-se observar que no FIFO o processo tem um

tempo de espera, j no prioridade esse tempo no
existe, visto que o processo de maior prioridade. No
SJF o tempo de espera foi de 0 tambm, entretanto isso
foi apenas coincidncia devido ao fato de o processo 7
ser o que possuia a menor tarefa a ser executada dentre
os 10 processos que foram descritos.
Todos os algoritmos fazem o esperado, apesar das
medidas realizadas, no possvel dizer com certeza
qual o melhor dentre os 3, o que pode-se dizer que
cada um tem suas vantagens e desvantagens.
5. Concluses
O estudo dos processos e todas as suas
caractersticas nos permite compreender de maneira
aprofundada o funcionamento de um dos setores
mais importantes do sistema operacional, que a
gerencia de processos. Os gerenciadores de processo
mudaram a forma com que os computadores trabalham,
diferentemente do que ocorria antigamente, quando s
era possvel executar uma aplicao de cada vez,
atualmente possvel trabalhar paralelamente em
diversas aplicaes.
Em paralelo ao estudo terico, importante que se
visualize as coisas na prtica e por isso a execuo do
projeto de um simulador de escalonamento de
processos permitiu que a teoria vista anteriormente
pudesse ser compreendida de maneira mais clara.
Dito isso, pode-se dizer que o estudo de processos
foi bem sucedido.
6. Referncias
TANENBAUM, A. S. Sistemas Operacionais Modernos. 3.
ed. So Paulo: Pearson Prentice Hall, 2009.
Processos
Anexos:
Tabela 1 Objetivos dos algoritmos de escalonamento
Processos
Cdigo fonte do simulador de escalonamento:

#include <stdio.h>
#include <stdlib.h>
typedef char *string;
struct bcp {
int id;
char bin[50]; //simulacao de uma sequencia de eventos de processo (1 - executando, 2-bloqueado para memoria,
3-bloqueado para IO
int prioridade; //varia de 0 a 3, quanto menor for o numero, maior a prioridade
int tamJob; //tamanho da tarefa
int CP; //contador de programa
int tempoChegada, tempoBloqMem, tempoBloqIO, tempoEspera; //tempos do processo
};
typedef struct bcp BCP;
BCP prontos[10]; //vetor utilizado para simular o escalonador
void carregaProcesso(string nome_arq){

FILE *procs;
procs = fopen(nome_arq, "r");
int i = 0;
int IN = 1;
if (procs == NULL){
printf("Erro ao abrir o arquivo de testes");
return;
}
while(!feof(procs)){
prontos[i].id = i;
prontos[i].prioridade = rand()%4; //define a prioridade de forma aleatoria
prontos[i].tamJob = 0;
prontos[i].CP = 0;
prontos[i].tempoChegada = IN; //definindo o tempo de chegada como a variavel IN, que vai variar de 1 a
10
fgets(prontos[i].bin,51,procs); //lendo a sequencia de tarefas que o processo pode executar e
armazenando em um vetor de char
i++;
IN++;
}
fclose(procs);
}
float media_tempoEspera(int n, BCP *prontos){ //calcula o tempo medio de espera dos processos
int i, aux;
aux=0;
float media;
for (i=0; i<n; i++){
aux = aux + prontos[i].tempoEspera;
}
media = aux/10;
return media;
}
void executa(int n, BCP *prontos, string LOG){
int i, j, aux;
aux = 0;
int tempo = 1;
FILE *arq;
for (i=0; i<n; i++){ //zerando as variaveis para nao conflitar na execucao
Processos
prontos[i].CP = 0;
}
arq = fopen(LOG, "wt"); // Cria um arquivo texto para gravao
if (arq == NULL){ // Se no conseguiu criar
printf("Problemas na CRIACAO do arquivo\n");
return;
}
for (i=0; i<10; i++){
for (j=0; j<40; j++){
//partes comentadas mostram a atividade do processo em cada ciclo
if (prontos[i].bin[j]=='1'){ //verificando o tempo que o processo ficou executando
//printf("Tempo %d processo %d executando \n", tempo, prontos[i].id);
prontos[i].CP++;
aux++;
}
if (prontos[i].bin[j]=='2'){ //verificando o tempo que o processo ficou bloqueado
//printf("Tempo %d processo %d bloqueado para memoria \n", tempo, prontos[i].id);
prontos[i].tempoBloqMem++;
aux++;
}
if (prontos[i].bin[j]=='3'){
//printf("Tempo %d processo %d bloqueado para fazer IO \n", tempo, prontos[i].id);
prontos[i].tempoBloqIO++;
aux++;
}
//printf("PROCESSO %d TERMINOU DE EXECUTAR \n", prontos[i].id);
//break;
}
tempo++;
}
fprintf(arq, "Processo %d com prioridade %d e que chegou no instante %d", prontos[i].id, prontos
[i].prioridade, prontos[i].tempoChegada);
fprintf(arq, "\n");
fprintf(arq, "Ficou executando por %d ciclos", prontos[i].CP);
fprintf(arq, "\n");
fprintf(arq, "Ficou bloqueado para memoria por %d ciclos", prontos[i].tempoBloqMem);
fprintf(arq, "\n");
fprintf(arq, "Ficou bloqueado para IO por %d ciclos", prontos[i].tempoBloqIO);
fprintf(arq, "\n");
fprintf(arq, "Ficou esperando por %d ciclos \n\n", prontos[i].tempoEspera);
prontos[i+1].tempoEspera = aux;
}
fprintf(arq, "O tempo, em ciclos, medio de espera para execuo foi de %f", media_tempoEspera(10,
prontos));
}
void FIFO (int n, BCP *prontos){
int i, j;
BCP aux;
//ordenando a fila/vetor por tempo de chegada
for(j=n-1; j>=1; j--){
for(i=0; i<j; i++){
if(prontos[i].tempoChegada>prontos[i+1].tempoChegada){
aux=prontos[i];
prontos[i]=prontos[i+1];
prontos[i+1]=aux;
}
}
}
executa(10, prontos, "LOG_FIFO.txt");
}
Processos
void PRIORIDADE (int n, BCP *prontos){

int i, j;
BCP aux;
//ordenando a fila/vetor de acordo com a prioridade
for(j=n-1; j>=1; j--){
for(i=0; i<j; i++){
if(prontos[i].prioridade>prontos[i+1].prioridade){
aux=prontos[i];
prontos[i+1]=aux;
}
}
}
executa(10, prontos, "LOG_PRIORIDADE.txt");
}
void SJF (int n, BCP *prontos){
int i, j, tamanho;
BCP aux;
//verificando o tamanho da tarefa
for (i=0; i<10; i++){
for (j=0; j<40; j++){
prontos[i].tamJob++;
}
}
}
//ordenando o a fila/vetor de acordo com o tamanho da tarefa (baseado no tempo em que o processo fica no
estado EXECUTANDO
for(j=n-1; j>=1; j--){
for(i=0; i<j; i++){
if(prontos[i].tamJob>prontos[i+1].tamJob){
aux=prontos[i];
prontos[i+1]=aux;
}
}
}
executa(10, prontos, "LOG_SJF.txt");
}
int main(){
carregaProcesso("teste.txt");
PRIORIDADE(10, prontos);
FIFO(10, prontos);
SJF(10, prontos);
}
Arquivo teste.txt
111111111111111111222222221111000000000
111111111111111122222222222222222222200
111111111111111113333333333330000000000
111111111111111222222222222222220000000
111111111111111111111111111122222222220
111111111111111111122200000000000000000
111111111111111111111121110000000000000
111111111111122222222222222222000000000
111111111111111111222211100000000000000
111111111111111122222222223333333300000
Processos
Relatrio FIFO:
Processo 0 com prioridade 3 e que chegou no instante 1
Ficou executando por 22 ciclos
Ficou bloqueado para memoria por 8 ciclos
Ficou bloqueado para IO por 0 ciclos
Ficou esperando por 0 ciclos
O tempo, em ciclos, medio de espera para execuo foi de 143.000000
10
Processos
Relatrio Prioridade:
11
Processos
Relatrio SJF:
12

Artigo Sobre Escalonamento de Processos

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Artigo Sobre Escalonamento de Processos

Diunggah oleh

Hak Cipta:

Format Tersedia

BCC34G Sistemas Operacionais

O modelo de processo pode ser compreendido

Figura 1 - Modelo de Processo

Em um sistema multiprogramado a CPU alterna

Na Figura 1-a, podem-se observar quatro

2.1 O modelo de processo

2.2 Criao de processos

Os processos so a abstrao mais importante que o

BCC34G Sistemas Operacionais

Para que um processo seja criado, preciso que

mostrada para que haja uma nova tentativa e o processo

2.5 Estados de processos

2.3 Trmino de processos

Figura 2 - Estados do processo

BCC34G Sistemas Operacionais

escalonamento no tem tanta importncia, devido ao

de maior tempo. Utilizando esse algoritmo, a mdia de

Figura 3 - Processos em surto de CPU e

Escalonamento em sistemas interativos:

-Primeiro a chegar, primeiro a ser servido

Escalonamento em sistemas de tempo real:

Existem dois tipos, o esttico, que quando a

BCC34G Sistemas Operacionais

dinmico que quando a deciso tomada durante a

void FIFO (int n, BCP *prontos);

A execuo foi feita atravs de uma anlise do vetor

BCC34G Sistemas Operacionais

Os parmetros utilizados, tanto nas funes de

Para exemplificar esse fato, os dados do processo

Tabela 1 - quadro comparativo de tempos de

Pode-se observar que no FIFO o processo tem um

BCC34G Sistemas Operacionais

Tabela 1 Objetivos dos algoritmos de escalonamento

BCC34G Sistemas Operacionais

Cdigo fonte do simulador de escalonamento:

void carregaProcesso(string nome_arq){

BCC34G Sistemas Operacionais

BCC34G Sistemas Operacionais

void PRIORIDADE (int n, BCP *prontos){

BCC34G Sistemas Operacionais

BCC34G Sistemas Operacionais

BCC34G Sistemas Operacionais

Anda mungkin juga menyukai