Relatorio PDF

PROJETO FINAL
Carlos Daniel Melim Menezes

Nº 2014718
Redes e Sistemas Informáticos (RSI)
UNIDADE CURRICULAR:
Introdução aos Sistemas Operativos
DOCENTE:
Luís Rodolfo Serrado Gomes Marques de Sousa
DATA:
08 de junho de 2019
1
Índice
Índice................................................................................................................................ 2
Lista de Figuras................................................................................................................ 3
1. Introdução.................................................................................................................... 5
2. Desenvolvimento do Script......................................................................................... 6
2.1. Estrutura Principal........................................................................................... 6
2.2. Verificação dos Parâmetros de Entrada..........................................................6

2.3. Valores dos Elementos do Sistema..................................................................8
2.3.1. Obtenção dos Valores.................................................................................... 8
2.3.1.1. Memória Principal...................................................................................... 8

2.3.1.2. Utilização do CPU........................................................................................9
2.3.1.3. Ocupação da Memória Secundária..........................................................10

2.3.1.4. Número de Processos...............................................................................11
2.3.1.5. Temperatura do CPU................................................................................11

2.3.2. Agregação de Valores a Arrays...................................................................12
2.4. Criação dos Gráficos....................................................................................... 13

2.5. Demonstração de Estatísticas........................................................................15
3. Execução do Script.....................................................................................................16
4. Webgrafia................................................................................................................... 18
5. Anexos........................................................................................................................ 19
5.1. Código do Script..............................................................................................19
2
Lista de Figuras
Figura 1 : Fluxograma do script..............................................................................6
Figura 2 : Função verificarParametros.................................................................. 7

Figura 3 : Obtenção de valores da memória principal..........................................8
Figura 4 : Obtenção do valor instantâneo da memória.........................................8

Figura 5 : Output do comando top -1..................................................................... 9
Figura 6 : Comando para obtenção da taxa de utilização do CPU........................9
Figura 7 : Validação do comando de obtenção da taxa de utilização do CPU... 10

Figura 8 : Comando para extração da taxa de ocupação da memória secundária.
.........................................................................................................................10
Figura 9 : Validação do comando de obtenção da taxa de ocupação da memória

secundária...................................................................................................... 10
Figura 10 : Comando de obtenção do número de processos a correr...............11

Figura 11 : Validação do comando de obtenção do número de processos a
serem executados (output não mostrado na integra)................................ 11
Figura 12 : Manipulação do número de processos............................................. 11
Figura 13 : Comando sensors............................................................................... 12

Figura 14 : Comando para extração da temperatura do CPU.............................12
Figura 15 : Inicialização de arrays........................................................................12

Figura 16 : Preenchimento de arrays e shift left dos valores.............................13
Figura 17 : Declaração e criação dos gráficos......................................................13

Figura 18 : Preenchimento dos arrays do gráfico............................................... 14
Figura 19 : Display dos gráficos no terminal.......................................................14
Figura 20 : Declaração de arrays para estatísticas............................................. 15

Figura 21 : Agregação dos valores instantâneos aos arrays.............................. 15
Figura 22 : Adição dos valores instantâneos a uma variável temporária......... 15

Figura 23 : Cálculo de médias e correspondente visualização.......................... 15
Figura 24 : Execução do script sem os parâmetros de entrada corretos.......... 16
Figura 25 : Estado inicial.......................................................................................16

3
Figura 26 : Gráficos passados dez ciclos de espera.............................................16
Figura 27 : Demonstração de estatísticas............................................................ 16
4
1. Introdução
Em Linux, os comandos base, são complementados por outros, desenvolvidos por
entusiastas, ou colaboradores, com o intuito de otimizar ou melhorar os mesmos.
O objetivo do projeto final para a disciplina de Introdução aos Sistemas Operativos

era a criação de um script, através da programação Bash, que permita a
visualização pseudográfica e em tempo real, de elementos do sistema operativo,
tais como o estado da memória principal, de utilização do processador, da
temperatura, do número de processos, entre outros.
Resumidamente, os seguintes gráficos deveriam ser apresentados ao utilizador na
execução do comando:
i. Ocupação da memória (percentagem);
ii. Utilização do CPU (percentagem);

iii. Número de processos ativos;
iv. Ocupação do disco (percentagem);
v. Temperatura média do CPU (em ºC).
5
2. Desenvolvimento do Script
O principal objetivo deste projeto era garantir que todos os gráficos eram
mostrados ao utilizador no terminal de maneira pseudográfica (através de
carateres ASCII).
De maneira a tornar o script o mais dinâmico possível, foi dada a oportunidade do
utilizador especificar o tempo de análise dos elementos do sistema operativo e
consequente atualização dos gráficos.
Visto que é possível aceder aos parâmetros de entrada de um script executado com
o intepretador Bash, foi esta a melhor maneira de estabelecer o tempo de
atualização.
2.1. Estrutura Principal

O comando $ ./status [refresh] executará que será responsável,
primeiramente, uma função responsável pela verificação dos parâmetros de
entrada. Caso os parâmetros de entrada satisfaçam os requisitos, são executados
os passos de obtenção/agregação dos valores e mostra dos gráficos.
O fluxograma seguinte demonstra a situação descrita:
Figura 1: Fluxograma do script.
2.2. Verificação dos Parâmetros de Entrada

A verificação dos parâmetros de entrada verifica apenas se o segundo parâmetro é
um número inteiro (um integer) . No interpretador Bash, o nome do script a
executar é o parâmetro 0 e tudo o resto pode ser acedido através de
$númeroargumento.
6
Neste caso, foi preciso analisar o parâmetro $1, cujo valor é atribuído à variável
refresh. O parâmetro passa por uma verificação, através de uma regular
expression, que verifica se tal parâmetro é um digito.
Caso refresh seja um dígito, a função simplesmente retorna. Caso contrário, é
mostrada uma mensagem de erro e o script acaba a sua execução através da
instrução exit.
A seguinte imagem ilustra a situação descrita:
Figura 2: Função verificarParametros.
7
2.3. Valores dos Elementos do Sistema
A obtenção dos valores instantâneos dos elementos do sistema operativo
passaram pelo armazenamento do resultado da execução de variáveis de sistema
em variáveis locais (variáveis exclusivas ao script), que depois são adicionados a
arrays.
Os capítulos seguintes descrevem o funcionamento da função adicionarValores.
2.3.1. Obtenção dos Valores

2.3.1.1. Memória Principal
O valor correspondente à ocupação da memória principal obtêm-se através do
comando $ free e várias mutações do mesmo.
Figura 3: Obtenção de valores da memória principal.
De maneira a preencher os arrays e, por consequência, os gráficos, com valores

múltiplos de 10 (0 a 100, com incrementos de 10 valores), foi necessário utilizar
algumas operações aritméticas. A maneira de arredondar o valor obtido com o
propósito de obter o múltiplo de 10 mais pequeno é ilustrada pela seguinte figura:
Figura 4: Obtenção do valor instantâneo da memória.

A mesma filosofia foi utilizada para arredondar os outros valores, pelo que este
passo será omitido em capítulos posteriores.
8
2.3.1.2. Utilização do CPU
A taxa de utilização do CPU é obtida através da execução do comando $ top -n1. O
último parâmetro especifica o número de vezes que os valores desse mesmo
comando são atualizados no ecrã (neste caso, uma única vez). A sua execução
resulta no seguinte output, e a parte a extrair foi assinalada a laranja:
Figura 5: Output do comando top -1.
A extração desse valor passou por várias manipulações. Primeiro, isolar a linha que
contém o valor e, posteriormente, obter a coluna e remover a casa decimal (bem
como a vírgula que a antecede). Para extrair o valor de utilização do CPU e realizar
todas as transformações supracitadas, os seguintes comandos foram utilizados:
Figura 6: Comando para obtenção da taxa de utilização do CPU.

Quando o valor de utilização do CPU é superior a 10,0us, a coluna a extrair
(parâmetro -f do terceiro pipe) é a 3, caso contrário, é a 2. Para evitar falhas na
execução do script, foi implementado um if statement que verifica se o valor não
existe, e em caso dessa condição se verificar, é porque o valor é superior a 10,0us.
Dado ser superior a 10,0us, o corte é feito noutra coluna.
O comando rev inverte a ordem de um número/string (25,5 ficará 5,52). O

parâmetro -c corta um certo número de carateres. Como a string foi invertida, e
como o valor de utilização do CPU é sempre arredondado até às décimas, podemos
9
cortar essa casa e a vírgula cortando a partir do terceiro carater (no exemplo acima,
a partir do segundo 5, ficando assim 52). Por fim, o valor é revertido de novo.
Figura 7: Validação do comando de obtenção da taxa de utilização do CPU.
2.3.1.3. Ocupação da Memória Secundária

O comando df reporta a taxa de ocupação do sistema de ficheiros do sistema
operativo. Este comando já reporta, também, a percentagem ocupada, pelo que
evita passos intermédios de cálculo de percentagem, ganhando assim tempo de
processamento.
O valor a extrair é a percentagem de utilização do disco /dev/sda1.
Figura 8: Comando para extração da taxa de ocupação da memória secundária.
Figura 9: Validação do comando de obtenção da taxa de ocupação da memória

secundária.
10
2.3.1.4. Número de Processos
O número de processos a serem executados, em simultâneo, num sistema, é obtido
através do comando cuja figura abaixo ilustra:
Figura 10: Comando de obtenção do número de processos a correr.
A flag --no-heading remove o cabeçalho presente no comando ps aux. Através de

um pipe, o comando wc -l conta o número de linhas, número esse que se traduz
no número de processos que estão a ser executados no sistema.
Figura 11: Validação do comando de obtenção do número de processos a serem

executados (output não mostrado na integra).
Visto que os gráficos têm a forma de percentagem/tempo, valor armazenado na
variável VALOR_PS é modificado de forma aos gráficos serem mostrados,
posteriormente, de maneira correta:
Figura 12: Manipulação do número de processos.
2.3.1.5. Temperatura do CPU

O comando sensors exibe a temperatura de cada core constituinte do CPU. Para
tal, a maneira de obter a temperatura instantânea do CPU foi somar a temperatura
de cada core e dividir pelo número total de cores da máquina.
11
Figura 13: Comando sensors.
Este foi, sem dúvida, o valor com extração mais complexa (em relação aos outros
valores). No entanto, apesar da complexidade, o script tornou-se ainda mais
dinâmico.
O comportamento deste excerto de código não foi testado em sistemas com mais
do que um processador.
Figura 14: Comando para extração da temperatura do CPU.
2.3.2. Agregação de Valores a Arrays

No início do programa, os arrays são declarados.
Figura 15: Inicialização de arrays.

Visto que os gráficos têm de ser preenchidos a começar na extremidade direita, é
feito um shift left do array a cada iteração e o último valor do array é preenchido
com o valor obtido.
Seja o preenchimento do array ARRAY_PS, referente ao número de processos,
exemplo para a situação descrita anteriormente:
12
Figura 16: Preenchimento de arrays e shift left dos valores.
2.4. Criação dos Gráficos

O último passo antes do ciclo de espera que remete ao parâmetro passado na
execução do script, é a criação e visualização dos próprios gráficos.
A cada ciclo de execução da função criarGraficos, os arrays que contêm as linhas

dos gráficos são declarados. Como a base de todos os gráficos é igual, apenas um
gráfico é inicializado e os restantes são uma cópia da base desse mesmo gráfico.
Figura 17: Declaração e criação dos gráficos.

De seguida, cada valor do array é analisado. Visto que, nesta fase, todos os valores
já foram arredondados para um múltiplo de 10, é apurado o valor de maneira a
preencher o gráfico.
Depende do valor, é adicionado, a cada linha, um carater e um espaço, caso o valor,
efetivamente, esteja compreendido nessa linha. Para as restantes, são adicionados
dois espaços.
13
Figura 18: Preenchimento dos arrays do gráfico.
No final de todas as verificações (de cada valor de cada um dos cinco arrays), os
gráficos são mostrados. Cada linha do gráfico é percorrida e imprimida no terminal,
tal como o código na figura abaixo mostra:
Figura 19: Display dos gráficos no terminal.
14
2.5. Demonstração de Estatísticas
De maneira a complementar todo o trabalho já efetuado, foi introduzida a
funcionalidade de mostrar as estatísticas da máquina aquando da finalização de
execução do programa (CTRL+C).
No início do programa, são declaradas arrays vazias que irão, posteriormente,
conter o valor instantâneo de cada elemento.
Figura 20: Declaração de arrays para estatísticas.
Cada vez que um valor é obtido, e antes do seu arredondamento, é adicionado ao

array correspondente.
Figura 21: Agregação dos valores instantâneos aos arrays.
O código trap tratarInterrupcao SIGINT; ordena a que, no caso das teclas

CTRL+C serem pressionadas, é executada a função tratarInterrupcao. Neste
função, a média dos valores instantâneos é calculada e, posteriormente, mostrada.
É, também, mostrado o tempo decorrido desde o início do script. Para tal, no início,
é declarada uma variável segundosPassados que, a cada ciclo, é incrementada.
Figura 22: Adição dos valores instantâneos a uma variável temporária.
Figura 23: Cálculo de médias e correspondente visualização.
15
3. Execução do Script
Em jeito de conclusão, são anexados algumas capturas de ecrã que demonstram o
programa em execução e o sucesso do trabalho.
Figura 24: Execução do script sem os parâmetros de entrada corretos.
Figura 25: Estado inicial.
Figura 26: Gráficos passados dez ciclos de espera.
Figura 27: Demonstração de estatísticas.
16
Conclui-se, portanto, que o trabalho foi executado com sucesso, atendendo aos
requisitos mencionados no enunciado do mesmo. Para além da aprendizagem de
uma nova linguagem de programação com a qual nunca tinha trabalhado, consegui
criar uma ferramenta útil para a análise dos recursos do sistema.
17
4. Webgrafia
https://books.goalkicker.com/BashBook/
http://stackoverflow.com/
https://www.reddit.com/r/bash/
18
5. Anexos
5.1. Código do Script
#!/bin/bash
refresh=$1
verificacoesFeitas=0
trap tratarInterrupcao SIGINT; # Executar a função

tratarInterrupcao quando CTRL + C for pressionado.
ARRAY_MEM=(0 0 0 0 0 0 0 0 0 0)
ARRAY_CPU=(0 0 0 0 0 0 0 0 0 0)
ARRAY_DSK=(0 0 0 0 0 0 0 0 0 0)
ARRAY_PS=(0 0 0 0 0 0 0 0 0 0)
ARRAY_TEMP=(0 0 0 0 0 0 0 0 0 0)
MEDIA_MEM=()
MEDIA_CPU=()
MEDIA_DSK=()
MEDIA_PS=()
MEDIA_TEMP=()
function tratarInterrupcao() {
TOTALMEDIAMEM=0
TOTALMEDIACPU=0
TOTALMEDIADSK=0
TOTALMEDIAPS=0
TOTALMEDIATEMP=0
for val in "${MEDIA_MEM[@]}"; do

(( TOTALMEDIAMEM+=$val ))
done
for val in "${MEDIA_CPU[@]}"; do

(( TOTALMEDIACPU+=$val ))
done
for val in "${MEDIA_DSK[@]}"; do

19
(( TOTALMEDIADSK+=$val ))
done
for val in "${MEDIA_PS[@]}"; do

(( TOTALMEDIAPS+=$val ))
done
for val in "${MEDIA_TEMP[@]}"; do

(( TOTALMEDIATEMP+=$val ))
done
clear
printf 'VERIFICAÇÔES FEITAS: %s | TEMPO DECORRIDO:

(%dh:%dm:%ds)\n' $verificacoesFeitas
$((($verificacoesFeitas*$refresh)/3600))
$((($verificacoesFeitas*$refresh)%3600/60))
$((($verificacoesFeitas*$refresh)%60))
echo -e "UTILIZAÇÃO MÉDIA DE MEMÓRIA:
$(( $TOTALMEDIAMEM / ${#MEDIA_MEM[@]} ))%"
echo -e "UTILIZAÇÃO MÉDIA DE CPU: $(( $TOTALMEDIACPU /
${#MEDIA_CPU[@]} ))%"
echo -e "OCUPAÇÃO MÉDIA DO DISCO: $(( $TOTALMEDIADSK /
${#MEDIA_DSK[@]} ))%"
echo -e "MÉDIA DE PROCESSOS EM SIMULTÂNEO:
$(( $TOTALMEDIAPS / ${#MEDIA_PS[@]} ))"
echo -e "TEMPERATURA MÉDIA DO CPU: $(( $TOTALMEDIATEMP
/ ${#MEDIA_TEMP[@]})) ºC"
exit 1;
}
function criarGraficos() {
declare -a graficoMEM
declare -a graficoCPU
declare -a graficoDSK
declare -a graficoPS
declare -a graficoTEMP
graficoCPU[0]=" CPU (%)"
20
graficoCPU[1]="100\u250C"
graficoCPU[2]=" 90\u251C"
graficoCPU[11]="
0\u2534\u252C\u2500\u252C\u2500\u252C\u2500\u252C\u2500\u25
2C\u2500\u252C\u2500\u252C\u2500\u252C\u2500\u252C\u2500\u2
52C\u2500"
graficoMEM+=(" Memória (%)")

graficoDSK+=(" Disco (%)")
graficoPS+=(" Processos (x10)")
graficoTEMP+=(" Temperatura (ºC)")
for((i=1; i < 12; i++)); do

graficoMEM+=(" ${graficoCPU[$i]}")
graficoDSK+=(" ${graficoCPU[$i]}")
graficoPS+=(" ${graficoCPU[$i]}")
graficoTEMP+=(" ${graficoCPU[$i]}")
done
for val in "${ARRAY_MEM[@]}";

do
case $val in
0)
graficoMEM[10]+=" "
graficoMEM[9]+=" "
graficoMEM[8]+=" "
graficoMEM[7]+=" "
graficoMEM[6]+=" "
graficoMEM[5]+=" "
graficoMEM[4]+=" "
graficoMEM[3]+=" "
21
graficoMEM[2]+=" "
graficoMEM[1]+=" "
;;
10)
graficoMEM[10]+="\u2584 "
graficoMEM[9]+=" "
graficoMEM[8]+=" "
graficoMEM[7]+=" "
graficoMEM[6]+=" "
graficoMEM[5]+=" "
graficoMEM[4]+=" "
graficoMEM[3]+=" "
graficoMEM[2]+=" "
graficoMEM[1]+=" "
;;
20)
graficoMEM[8]+=" "
graficoMEM[7]+=" "
graficoMEM[6]+=" "
graficoMEM[5]+=" "
graficoMEM[4]+=" "
graficoMEM[3]+=" "
graficoMEM[2]+=" "
graficoMEM[1]+=" "
;;
30)
graficoMEM[7]+=" "
graficoMEM[6]+=" "
graficoMEM[5]+=" "
graficoMEM[4]+=" "
graficoMEM[3]+=" "
graficoMEM[2]+=" "
graficoMEM[1]+=" "
22
;;
40)
graficoMEM[6]+=" "
graficoMEM[5]+=" "
graficoMEM[4]+=" "
graficoMEM[3]+=" "
graficoMEM[2]+=" "
graficoMEM[1]+=" "
;;
50)
graficoMEM[5]+=" "
graficoMEM[4]+=" "
graficoMEM[3]+=" "
graficoMEM[2]+=" "
graficoMEM[1]+=" "
;;
60)
graficoMEM[4]+=" "
graficoMEM[3]+=" "
graficoMEM[2]+=" "
graficoMEM[1]+=" "
;;
70)
23
graficoMEM[3]+=" "
graficoMEM[2]+=" "
graficoMEM[1]+=" "
;;
80)
graficoMEM[2]+=" "
graficoMEM[1]+=" "
;;
90)
graficoMEM[1]+=" "
;;
100)
24
;;
esac
done
for valorCPU in "${ARRAY_CPU[@]}";

do
case $valorCPU in
0)
graficoCPU[10]+=" "
graficoCPU[9]+=" "
graficoCPU[8]+=" "
graficoCPU[7]+=" "
graficoCPU[6]+=" "
graficoCPU[5]+=" "
graficoCPU[4]+=" "
graficoCPU[3]+=" "
graficoCPU[2]+=" "
graficoCPU[1]+=" "
;;
10)
graficoCPU[10]+="\u2584 "
graficoCPU[9]+=" "
graficoCPU[8]+=" "
graficoCPU[7]+=" "
graficoCPU[6]+=" "
graficoCPU[5]+=" "
graficoCPU[4]+=" "
graficoCPU[3]+=" "
graficoCPU[2]+=" "
graficoCPU[1]+=" "
25
;;
20)
graficoCPU[8]+=" "
graficoCPU[7]+=" "
graficoCPU[6]+=" "
graficoCPU[5]+=" "
graficoCPU[4]+=" "
graficoCPU[3]+=" "
graficoCPU[2]+=" "
graficoCPU[1]+=" "
;;
30)
graficoCPU[7]+=" "
graficoCPU[6]+=" "
graficoCPU[5]+=" "
graficoCPU[4]+=" "
graficoCPU[3]+=" "
graficoCPU[2]+=" "
graficoCPU[1]+=" "
;;
40)
graficoCPU[6]+=" "
graficoCPU[5]+=" "
graficoCPU[4]+=" "
graficoCPU[3]+=" "
graficoCPU[2]+=" "
graficoCPU[1]+=" "
;;
50)
26
graficoCPU[5]+=" "
graficoCPU[4]+=" "
graficoCPU[3]+=" "
graficoCPU[2]+=" "
graficoCPU[1]+=" "
;;
60)
graficoCPU[4]+=" "
graficoCPU[3]+=" "
graficoCPU[2]+=" "
graficoCPU[1]+=" "
;;
70)
graficoCPU[3]+=" "
graficoCPU[2]+=" "
graficoCPU[1]+=" "
;;
80)
27
graficoCPU[2]+=" "
graficoCPU[1]+=" "
;;
90)
graficoCPU[1]+=" "
;;
100)
;;
esac
done
for valorDSK in "${ARRAY_DSK[@]}";

do
28
case $valorDSK in
0)
graficoDSK[10]+=" "
graficoDSK[9]+=" "
graficoDSK[8]+=" "
graficoDSK[7]+=" "
graficoDSK[6]+=" "
graficoDSK[5]+=" "
graficoDSK[4]+=" "
graficoDSK[3]+=" "
graficoDSK[2]+=" "
graficoDSK[1]+=" "
;;
10)
graficoDSK[10]+="\u2584 "
graficoDSK[9]+=" "
graficoDSK[8]+=" "
graficoDSK[7]+=" "
graficoDSK[6]+=" "
graficoDSK[5]+=" "
graficoDSK[4]+=" "
graficoDSK[3]+=" "
graficoDSK[2]+=" "
graficoDSK[1]+=" "
;;
20)
graficoDSK[8]+=" "
graficoDSK[7]+=" "
graficoDSK[6]+=" "
graficoDSK[5]+=" "
graficoDSK[4]+=" "
graficoDSK[3]+=" "
graficoDSK[2]+=" "
graficoDSK[1]+=" "
;;
30)
29
graficoDSK[7]+=" "
graficoDSK[6]+=" "
graficoDSK[5]+=" "
graficoDSK[4]+=" "
graficoDSK[3]+=" "
graficoDSK[2]+=" "
graficoDSK[1]+=" "
;;
40)
graficoDSK[6]+=" "
graficoDSK[5]+=" "
graficoDSK[4]+=" "
graficoDSK[3]+=" "
graficoDSK[2]+=" "
graficoDSK[1]+=" "
;;
50)
graficoDSK[5]+=" "
graficoDSK[4]+=" "
graficoDSK[3]+=" "
graficoDSK[2]+=" "
graficoDSK[1]+=" "
;;
60)
30
graficoDSK[4]+=" "
graficoDSK[3]+=" "
graficoDSK[2]+=" "
graficoDSK[1]+=" "
;;
70)
graficoDSK[3]+=" "
graficoDSK[2]+=" "
graficoDSK[1]+=" "
;;
80)
graficoDSK[2]+=" "
graficoDSK[1]+=" "
;;
90)
31
graficoDSK[1]+=" "
;;
100)
;;
esac
done
for valorPS in "${ARRAY_PS[@]}";

do
case $valorPS in
0)
graficoPS[10]+=" "
graficoPS[9]+=" "
graficoPS[8]+=" "
graficoPS[7]+=" "
graficoPS[6]+=" "
graficoPS[5]+=" "
graficoPS[4]+=" "
graficoPS[3]+=" "
graficoPS[2]+=" "
graficoPS[1]+=" "
;;
32
10)
graficoPS[10]+="\u2584 "
graficoPS[9]+=" "
graficoPS[8]+=" "
graficoPS[7]+=" "
graficoPS[6]+=" "
graficoPS[5]+=" "
graficoPS[4]+=" "
graficoPS[3]+=" "
graficoPS[2]+=" "
graficoPS[1]+=" "
;;
20)
graficoPS[8]+=" "
graficoPS[7]+=" "
graficoPS[6]+=" "
graficoPS[5]+=" "
graficoPS[4]+=" "
graficoPS[3]+=" "
graficoPS[2]+=" "
graficoPS[1]+=" "
;;
30)
graficoPS[7]+=" "
graficoPS[6]+=" "
graficoPS[5]+=" "
graficoPS[4]+=" "
graficoPS[3]+=" "
graficoPS[2]+=" "
graficoPS[1]+=" "
;;
40)
33
graficoPS[6]+=" "
graficoPS[5]+=" "
graficoPS[4]+=" "
graficoPS[3]+=" "
graficoPS[2]+=" "
graficoPS[1]+=" "
;;
50)
graficoPS[5]+=" "
graficoPS[4]+=" "
graficoPS[3]+=" "
graficoPS[2]+=" "
graficoPS[1]+=" "
;;
60)
graficoPS[4]+=" "
graficoPS[3]+=" "
graficoPS[2]+=" "
graficoPS[1]+=" "
;;
70)
34
graficoPS[3]+=" "
graficoPS[2]+=" "
graficoPS[1]+=" "
;;
80)
graficoPS[2]+=" "
graficoPS[1]+=" "
;;
90)
graficoPS[1]+=" "
;;
100)
35
;;
esac
done
for valorTEMP in "${ARRAY_TEMP[@]}";

do
case $valorTEMP in
0)
graficoTEMP[10]+=" "
graficoTEMP[9]+=" "
graficoTEMP[8]+=" "
graficoTEMP[7]+=" "
graficoTEMP[6]+=" "
graficoTEMP[5]+=" "
graficoTEMP[4]+=" "
graficoTEMP[3]+=" "
graficoTEMP[2]+=" "
graficoTEMP[1]+=" "
;;
10)
graficoTEMP[10]+="\u2584 "
graficoTEMP[9]+=" "
graficoTEMP[8]+=" "
graficoTEMP[7]+=" "
graficoTEMP[6]+=" "
graficoTEMP[5]+=" "
graficoTEMP[4]+=" "
graficoTEMP[3]+=" "
graficoTEMP[2]+=" "
graficoTEMP[1]+=" "
;;
20)
36
graficoTEMP[8]+=" "
graficoTEMP[7]+=" "
graficoTEMP[6]+=" "
graficoTEMP[5]+=" "
graficoTEMP[4]+=" "
graficoTEMP[3]+=" "
graficoTEMP[2]+=" "
graficoTEMP[1]+=" "
;;
30)
graficoTEMP[7]+=" "
graficoTEMP[6]+=" "
graficoTEMP[5]+=" "
graficoTEMP[4]+=" "
graficoTEMP[3]+=" "
graficoTEMP[2]+=" "
graficoTEMP[1]+=" "
;;
40)
graficoTEMP[6]+=" "
graficoTEMP[5]+=" "
graficoTEMP[4]+=" "
graficoTEMP[3]+=" "
graficoTEMP[2]+=" "
graficoTEMP[1]+=" "
;;
50)
37
graficoTEMP[5]+=" "
graficoTEMP[4]+=" "
graficoTEMP[3]+=" "
graficoTEMP[2]+=" "
graficoTEMP[1]+=" "
;;
60)
graficoTEMP[4]+=" "
graficoTEMP[3]+=" "
graficoTEMP[2]+=" "
graficoTEMP[1]+=" "
;;
70)
graficoTEMP[3]+=" "
graficoTEMP[2]+=" "
graficoTEMP[1]+=" "
;;
80)
38
graficoTEMP[2]+=" "
graficoTEMP[1]+=" "
;;
90)
graficoTEMP[1]+=" "
;;
100)
;;
esac
done
clear
echo -e "\n\n\n\n"
for (( idx=0; idx < 12; idx++ )); do
39
echo -e "${graficoMEM[$idx]} ${graficoCPU[$idx]}"
done
echo -e "\n"
for (( idx=0; idx < 12; idx++ )); do

echo -e "${graficoDSK[$idx]} ${graficoPS[$idx]}
${graficoTEMP[$idx]}"
done
echo -e "\n"
return
}
function adicionarValores() {
TOTAL_MEM=$(free | head -n 2 | tail -n 1 | cut -d ' ' -f9)
# Valor total da memória.
USADO_MEM=$(free | head -n 2 | tail -n 1 | cut -d ' ' -f14)
# Valor usado da memória.
VALOR_MEM=$(($USADO_MEM * 100)) # O arredonda todas as
divisões para o número inteiro menor, portanto multiplica-
se por 100.
VALOR_MEM=$(($VALOR_MEM / $TOTAL_MEM)) # Aritmética para
obtenção do valor de ocupação instantânea da memória.
MEDIA_MEM+=($VALOR_MEM)
VALOR_MEM=$(($VALOR_MEM/10)) # Arredondamento para o
múltiplo de 10 inferior a VALOR_MEM.
VALOR_MEM=$(($VALOR_MEM * 10)) # Arredondamento para o
múltiplo de 10 inferior a VALOR_MEM. Ex: (55/10) = 5.5 = 5;
5 * 10 = 50
for (( i = 0; i < 11; i++ ))

do
ARRAY_MEM[$i]=${ARRAY_MEM[i+1]}
done
ARRAY_MEM[9]=$VALOR_MEM
VALOR_CPU=$(top -n1 | head -n3 | tail -n1 | cut -d ' ' -f2
| rev | cut -c 3- | rev)
if [ $VALOR_CPU = " " ]; then
40
VALOR_CPU=$(top -n1 | head -n3 | tail -n1 | cut -d
' ' -f3 | rev | cut -c 3- | rev)
fi
MEDIA_CPU+=($VALOR_CPU)
VALOR_CPU=$(($VALOR_CPU / 10))
VALOR_CPU=$(($VALOR_CPU * 10))
for (( i = 0; i < 11; i++ ))
do
ARRAY_CPU[$i]=${ARRAY_CPU[i+1]}
done
ARRAY_CPU[9]=$VALOR_CPU
VALOR_DSK=$(df | grep "/dev/sda1" | cut -d ' ' -f12)

VALOR_DSK=${VALOR_DSK%?} # Remove o último carater do valor
(%)
MEDIA_DSK+=($VALOR_DSK)
VALOR_DSK=$(($VALOR_DSK / 10))
VALOR_DSK=$(($VALOR_DSK * 10))
for (( i = 0; i < 11; i++ ))
do
ARRAY_DSK[$i]=${ARRAY_DSK[i+1]}
done
ARRAY_DSK[9]=$VALOR_DSK
VALOR_PS=$(ps aux --no-heading | wc -l)

MEDIA_PS+=($VALOR_PS)
if (( $VALOR_PS < 100 )); # Se o número de processos
for inferior a 100
then
VALOR_PS=${VALOR_PS:0:1} # O primeiro dígito é
extraido. Ex: 99 -> 9 -> 0 no gráfico
else # Caso contrário (>= 100)
VALOR_PS=${VALOR_PS:0:2} # Os dois primeiros
dígitos são extraidos. Ex: 120 -> 12 -> 10 no gráfico
fi
VALOR_PS=$(($VALOR_PS / 10))
VALOR_PS=$(($VALOR_PS * 10))
41
for (( i = 0; i < 11; i++ ))
do
ARRAY_PS[$i]=${ARRAY_PS[i+1]} # Ex: ARRAY_PS[1] =
ARRAY_PS[2]
done
ARRAY_PS[9]=$VALOR_PS # O último valor é preenchido com
o valor obtido neste ciclo.
NUMCORES=$(sensors | wc -l) # Conta o número de linhas.

NUMCORES=$((NUMCORES-2)) # Utilizado posteriormente
para extrair todas as linhas menos as duas primeiras.
CORES=$(sensors | tail -n$NUMCORES | cut -d ' ' -f9 |

cut -c2-3) # Extrai as temperaturas (output já sanitizado)
VALOR_TEMP=0
for core in $CORES; do

((VALOR_TEMP+=$core)) # Para cada temperatura,
adicionar tal valor à variável VALOR_TEMP
done
((VALOR_TEMP=$VALOR_TEMP/($NUMCORES-1))) # VALOR_TEMP
passa a ser a média da temperatura de todos so cores.
$NUMCORES inclui a contagem de uma linha em branco, pelo
que essa linha é removida com $NUMCORES-1.
MEDIA_TEMP+=($VALOR_TEMP)
((VALOR_TEMP=$VALOR_TEMP / 10))
((VALOR_TEMP=$VALOR_TEMP * 10))
for (( i = 0; i < 11; i++ ))

do
ARRAY_TEMP[$i]=${ARRAY_TEMP[i+1]}
done
ARRAY_TEMP[9]=$VALOR_TEMP
return
}
42
function verificarParametros {
if ! [[ $refresh == ?(-)+([0-9]) ]];
then
echo -e "\e[91mUSO: $ status [refresh: INT]\trefresh:
0-\u221e" >&2;
exit;
fi
return
}
verificarParametros # Verificar se os paramêtros

introduzidos no início estão corretos.
while (( 1 == 1)); do
adicionarValores
criarGraficos
(( verificacoesFeitas++ ))
sleep $refresh
done
43

Relatorio PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Relatorio PDF

Caricato da

Copyright:

Formati disponibili

PROJETO FINAL

Carlos Daniel Melim Menezes

Redes e Sistemas Informáticos (RSI)

2.2. Verificação dos Parâmetros de Entrada..........................................................6

2.3.1. Obtenção dos Valores.................................................................................... 8

2.3.1.1. Memória Principal...................................................................................... 8

2.3.1.3. Ocupação da Memória Secundária..........................................................10

2.3.1.5. Temperatura do CPU................................................................................11

2.4. Criação dos Gráficos....................................................................................... 13

5.1. Código do Script..............................................................................................19

Figura 2 : Função verificarParametros.................................................................. 7

Figura 4 : Obtenção do valor instantâneo da memória.........................................8

Figura 6 : Comando para obtenção da taxa de utilização do CPU........................9

Figura 7 : Validação do comando de obtenção da taxa de utilização do CPU... 10

Figura 9 : Validação do comando de obtenção da taxa de ocupação da memória

Figura 10 : Comando de obtenção do número de processos a correr...............11

Figura 13 : Comando sensors............................................................................... 12

Figura 15 : Inicialização de arrays........................................................................12

Figura 17 : Declaração e criação dos gráficos......................................................13

Figura 19 : Display dos gráficos no terminal.......................................................14

Figura 20 : Declaração de arrays para estatísticas............................................. 15

Figura 22 : Adição dos valores instantâneos a uma variável temporária......... 15

Figura 24 : Execução do script sem os parâmetros de entrada corretos.......... 16

Figura 25 : Estado inicial.......................................................................................16

O objetivo do projeto final para a disciplina de Introdução aos Sistemas Operativos

ii. Utilização do CPU (percentagem);

iv. Ocupação do disco (percentagem);

v. Temperatura média do CPU (em ºC).

2.1. Estrutura Principal

O fluxograma seguinte demonstra a situação descrita:

Figura 1: Fluxograma do script.

2.2. Verificação dos Parâmetros de Entrada

A seguinte imagem ilustra a situação descrita:

Figura 2: Função verificarParametros.

Os capítulos seguintes descrevem o funcionamento da função adicionarValores.

2.3.1. Obtenção dos Valores

Figura 3: Obtenção de valores da memória principal.

De maneira a preencher os arrays e, por consequência, os gráficos, com valores

Figura 4: Obtenção do valor instantâneo da memória.

Figura 5: Output do comando top -1.

Figura 6: Comando para obtenção da taxa de utilização do CPU.

O comando rev inverte a ordem de um número/string (25,5 ficará 5,52). O

Figura 7: Validação do comando de obtenção da taxa de utilização do CPU.

2.3.1.3. Ocupação da Memória Secundária

Figura 8: Comando para extração da taxa de ocupação da memória secundária.

Figura 9: Validação do comando de obtenção da taxa de ocupação da memória

Figura 10: Comando de obtenção do número de processos a correr.

A flag --no-heading remove o cabeçalho presente no comando ps aux. Através de

Figura 11: Validação do comando de obtenção do número de processos a serem

Figura 12: Manipulação do número de processos.

2.3.1.5. Temperatura do CPU

Figura 14: Comando para extração da temperatura do CPU.

2.3.2. Agregação de Valores a Arrays

Figura 15: Inicialização de arrays.

2.4. Criação dos Gráficos

A cada ciclo de execução da função criarGraficos, os arrays que contêm as linhas

Figura 17: Declaração e criação dos gráficos.

Figura 19: Display dos gráficos no terminal.

Figura 20: Declaração de arrays para estatísticas.

Cada vez que um valor é obtido, e antes do seu arredondamento, é adicionado ao

Figura 21: Agregação dos valores instantâneos aos arrays.

O código trap tratarInterrupcao SIGINT; ordena a que, no caso das teclas

Figura 22: Adição dos valores instantâneos a uma variável temporária.