MEMORIA PRACTICA 1

DISEÑO Y ADMINISTRACIÓN DE SISTEMAS

OPERATIVOS

Mitop.sh

Explicación general del funcionamiento del programa:

El programa se divide en 3 partes:

-La primera parte recopila la información de carácter general del ordenador y que se muestra
inmediatamente en la cabecera (memoria usada, libre y total), porcentaje de uso de la CPU y
otra información que se usara más adelante, como el tamaño de página.

-La segunda parte es un bucle que recorre todas las carpetas numéricas de /proc y en el cual se
recopila información respectiva al tiempo de ejecución de los procesos y se espera 1 segundo
(Esto es necesario para un cálculo correcto del porcentaje de uso de la CPU)

-La tercera y última parte consta de un bucle que recorre una vez más todas las carpetas
numéricas de /proc y en el que se recopilan o calculan todos los datos necesarios de cada
proceso para mostrar por pantalla la información necesaria para la práctica.

Explicación detallada del funcionamiento del programa:

Parte 1: Cabecera:

Obtenemos los datos del número de procesos de la cantidad de carpetas numéricas que se
encuentra en ./proc y lo imprimimos

numProcs="$( ls -l | aw k '{print $9}' |grep -e '9\>' -e '8\>' -e '9\>' -e '7\>' -e

'6\>' -e '5\>' -e '4\>' -e '3\>' -e '2\>' -e '1\>' -e '0\>'| w c -l)"

echo -e '\e[1;33mNumero de procesos: \e[0m' $numProcs

Obtenemos la memoria disponible del archivo stat de de la carpeta ./proc y calculamos la

memoria usada y la mostramos

memtotal=${MAPFI LE[0]#*:}

memtotal="${memtotal::-3}"

memtotal=${memtotal//[[:blank:]]/}

memfree=${MAPFILE[1]#*:}

memfree="${memfree::-3}"

Alejandro Duque Quintana

memfree=${memfree//[[:blank:]]/}

memused="$(($memtotal - $memfree))"

memline="Memoria total: "$memtotal" KB, Memoria libre: "$memfree" KB,

Memoria usada: "$memused" KB"

echo -e "$memline"

Además, guardamos los datos del tamaño de página y de los ticks

ttime=$(getconf CLK_TCK)

mapped=$(cat /proc/meminfo | grep ^Mapped | aw k '{print $2}')

nrMapped=$(awk '/nr_mapped/ {print $2}' < /proc/vmstat)

pageSize=$(($mapped/$nrMapped))

Parte 2: Primer Bucle:

Iniciamos el contador a 1

Obtenemos la lista de procesos y el número de procesos

procs="$( ls -l | aw k '{print $9}' |grep -e '9\>' -e '8\>' -e '9\>' -e '7\>' -e '6\>' -e

'5\>' -e '4\>' -e '3\>' -e '2\>' -e '1\>' -e '0\>' | paste -sd "," -)"

I FS=','

total=`ls -la /proc | aw k '{print $9}' | grep "[0-9]" | w c -l`

Recorremos la lista de procesos y obtenemos el tiempo de ejecución en modo usuario y modo

núcleo del archivo stat y los sumamos para calcular el tiempo total de ejecución

modoNucleo[$contador]=$(cat "/proc/$pid/stat" 2> /dev/null | aw k '{ print $14

}')

modoUsuario[$contador]=$(cat "/proc/$pid/stat" 2> /dev/null | aw k '{ print

$15 }')

enUsuario=${modoUsuario[$contador]}

enNucleo=${modoNucleo[$contador]}

if [ -z $enUsuario ] || [ -z $enNucleo ]; then

echo > /dev /null

else

Alejandro Duque Quintana

 totalTiempo1[$contador]=$((${modoNucleo[$contador]}+${modoUsuari
o[$contador]}))

Parte 3: Primer Bucle:

Realizamos un bucle para obtener todos los datos de todos los procesos

w hile [ $contador -le $total ];

do

Obtenemos el identificador del usuario que invoco al proceso de su archivo stat y lo

almacenamos en variable

id=`aw k '/Uid/ {print $2}' 2> /dev /null < /proc/$pid/status`

A continuación, para obtener su nombre lo comparamos con el archivo /etc/passwd y lo

guardamos en una variable

user=`awk -F : -v v ar="$id" '{ if ($3 == v ar) print $1}' /etc/passwd`

prior=$(aw k '{print $18}' 2> /dev /null < /proc/$pid/stat)

Obtenemos su prioridad de su archivo stat y la almacenamos en una variable

prior=$(aw k '{print $18}' 2> /dev /null < /proc/$pid/stat)

Obtenemos la cantidad de memoria virtual del proceso de su archivo stat y la almacenamos en

variable

mVirt=$(aw k '{print $23}' 2> /dev /null < /proc/$pid/stat)

Obtenemos el estado del proceso de su archivo stat y lo almacenamos en variable

est=$(aw k '{print $3}' 2> /dev /null < /proc/$pid/stat)

Obtenemos el nombre del programa que invoca al proceso de su archivo stat y lo

almacenamos en variable

comm=$(aw k '{print $2}' 2> /dev /null < /proc/$pid/stat | sed

's/^.\|.$//g')

Alejandro Duque Quintana

Calculamos el porcentaje de memoria usada por el proceso obteniendo el valor y
multiplicándolo por el tamaño de página y dividiéndolo por la memoria total

rss=$(aw k '{print $24}' 2> /dev /null < /proc/$pid/stat)

if [ -z $rss ] || [ $rss -eq 0 ]; then

mem=0

else

mem=$(echo "scale = 3; (($rss*$pageSize)/$memtotal)*100" | bc

2> /dev /null | aw k '{printf "%.2f", $0}' | aw k '{if($0 ~ /\./) sub("\\.*0+$","");print}')

fi

tiempo=$(aw k '{print $22}' 2> /dev /null < /proc/$pid/stat)

if [ -z $tiempo ]; then

tiempo=0

fi
Calculamos el tiempo total en ejecución del procesador restando al instante hasta el que
estuvo activo el instante que se inicio y lo pasamos a horas y minutos

uptime=$(aw k '{print $1}' < /proc/uptime)

segundos=$((${uptime%.*}-$tiempo/ $ttime))

TI ME=$(printf '%dh:%dm:%ds\n' $(($segundos/3600))

$(($segundos%3600/60)) $(($segundos%60)))

Calculamos el porcentaje de uso del procesador para ello restamos el tiempo en ejecución
total del procesador, la nueva medición la medición antigua y lo dividimos entre los ticks del
reloj.

cutime=$(aw k '{print $16}' 2> /dev /null < /proc/$pid/stat)

cstime=$(aw k '{print $17}' 2> /dev /null < /proc/$pid/stat)

starttime=$(aw k '{print $22}' 2> /dev /null < /proc/$pid/stat)

modoNucleo[$contador]=$(cat "/proc/$pid/stat" 2> /dev/null | aw k

'{print $14 }')

modoUsuario[$contador]=$(cat "/proc/$pid/stat" 2> /dev/null | aw k '{print

$15 }')

enUsuario=${modoUsuario[$contador]} 2> /dev /null

enNucleo=${modoNucleo[$contador]} 2> /dev /null

if [ -z $enUsuario ] || [ -z $enNucleo ];

then

Alejandro Duque Quintana

 echo > /dev /null

else

totalTiempo2[$contador]=$((${modoNucleo[$contador]}+${modoUsuari
o[$contador]}))

if [ -z ${totalTiempo2[$contador]} ] || [ -z
${totalTiempo1[$contador]} ];

then

echo > /dev /null

else

totalTiempo2[$contador]=$((${totalTiempo2[$contador]}-
${totalTiempo1[$contador]})) 2> /dev /null

totalTiempo2[$contador]=$((${totalTiempo2[$contador]}+$cutime+$csti
me))

uptime=$(aw k '{print $1}' < /proc/uptime)

starttime_ttime=$(echo "scale = 2; $starttime/$ttime" | bc)

segundos=$(echo "scale = 2; $uptime-$starttime_ttime" |

bc)

totaltime[$contador]=$(echo "scale = 2;
${totalTiempo2[$contador]} / $ttime" | bc)

ttseg[$contador]=$(echo "scale = 3;
${totaltime[$contador]}/$segundos" | bc)

ttseg[$contador]=$(echo "scale = 3;
${totaltime[$contador]}/$segundos" | bc)

CPU[$contador]=$(echo "scale = 2;
${ttseg[$contador]}*100" | bc | aw k '{printf "%.2f", $0}')

Por último mostramos los datos

printf "%-10s %-10s %-10s %-10s %-10s %-10s %-10s %-11s %-10s\n"
"$pid" "$user" "$prior" "$mVirt" "$est" "${CPU[$contador]}" "$mem" "$TIME" "$comm"

Alejandro Duque Quintana