Pràctica 4: Monitoratge de Fils amb Comandes Bash

Objectius

• Aprendre a identificar fils (threads) d'un procés
• Utilitzar comandes de sistema per monitorar recursos dels fils
• Comparar comportament entre aplicacions en C i Python
• Automatitzar tasques bàsiques de monitoratge amb scripts simples

Material necessari

• Programa fils01 (versió C compilada)
• Programa fils01.py (versió Python)
• Accés a les comandes: ps, top, htop (opcional), pstree

Preparació

1. Compilar el programa C

gcc -pthread fils01.c -o fils01

Si no tens gcc instal·lat:

sudo apt-get install build-essential

2. Verificar el programa Python

python3 fils01.py --help 2>/dev/null || echo "El programa està llest"

3. Verificar dependències

# Verificar comandes disponibles
for cmd in ps top pstree; do
    command -v $cmd >/dev/null && echo "✓ $cmd disponible" || echo "✗ $cmd NO disponible"
done

Part 1: Identificació bàsica de fils (3 punts)

Exercici 1.1: Executar i identificar el procés (0.5 punts)

1. En un terminal, executa el programa C amb 4 fils durant 180 segons:

   ./fils01 4 180
   

   📋

2. PREGUNTA: Quin és el PID del procés que s'ha creat? (el programa ho mostra)

3. TASCA: En un segon terminal, verifica que el procés està en execució:

   ps aux | grep fils01
   

   📋

4. PREGUNTA: A més del procés fils01, quins altres processos relacionats amb fils01 apareixen? Per què?

Exercici 1.2: Llistar els fils (1 punt)

1. Utilitza la comanda ps per llistar tots els fils del procés:

   ps -p <PID> -T
   

   📋

   (Substitueix <PID> pel PID real del teu procés)

2. PREGUNTA: Quants fils té el procés? (compte: suma el fil principal + els fils creats)

3. TASCA: Captura la sortida en un fitxer:

   ps -p <PID> -T > exercici1_2.txt
   

   📋

Exercici 1.3: Informació detallada dels fils (1 punt)

1. Executa la comanda següent per veure informació detallada:

   ps -p <PID> -L -o pid,tid,pcpu,pmem,stat,comm
   

   📋

2. PREGUNTA: Quin és el TID (Thread ID) de cada fil?

3. PREGUNTA: Quin fil (TID) està consumint més CPU? (mira la columna %CPU)

4. TASCA: Captura aquesta informació:

   ps -p <PID> -L -o pid,tid,pcpu,pmem,stat,comm > exercici1_3.txt
   

   📋

Exercici 1.4: Visualització jeràrquica (0.5 punts)

1. Utilitza pstree per veure l'estructura:

   pstree -p <PID> -t
   

   📋

2. PREGUNTA: Com es representen els fils en la sortida de pstree?

3. TASCA: Guarda la sortida:

   pstree -p <PID> -t > exercici1_4.txt
   

   📋

Part 2: Monitoratge en temps real (3 punts)

Exercici 2.1: Utilitzar top bàsic (1 punt)

1. Si el programa anterior encara s'està executant, perfecte. Si no, torna a executar-lo.

2. Obre top en mode fils:

   top -H -p <PID>
   

   📋

3. PREGUNTA: Quants fils veus a la llista?

4. TASCA: Dins de top:

   • Prem P per ordenar per CPU
   • Prem M per ordenar per memòria
   • Prem q per sortir

5. PREGUNTA: Quin fil (TID) consumeix més CPU? És el mateix que a l'exercici anterior?

Exercici 2.2: Capturar dades de top (1 punt)

1. Executa top en mode batch per capturar una instantània:

   top -H -p <PID> -b -n 1 > exercici2_2.txt
   

   📋

2. TASCA: Obre el fitxer exercici2_2.txt i respon:

   • Quin percentatge de CPU utilitza cada fil?
   • Quanta memòria (RES) utilitza el procés en total?

Exercici 2.3: Monitoratge continu (1 punt)

1. Executa aquesta comanda per veure l'evolució cada 2 segons:

   watch -n 2 "ps -p <PID> -L -o pid,tid,pcpu,pmem,stat,comm"
   

   📋

2. PREGUNTA: Els percentatges de CPU canvien molt entre actualitzacions? Per què creus que passa això?

3. Prem Ctrl+C per sortir.

Part 3: Comparació C vs Python (2 punts)

Exercici 3.1: Executar programa Python (0.5 punts)

1. En un altre terminal, executa el programa Python amb els mateixos paràmetres:

   python3 fils01.py 4 180
   

   📋

2. PREGUNTA: Quin és el PID d'aquest nou procés?

Exercici 3.2: Comptar fils (0.5 punts)

1. Per al programa C:

   ps -p <PID_C> -T --no-headers | wc -l
   

   📋

2. Per al programa Python:

   ps -p <PID_PYTHON> -T --no-headers | wc -l
   

   📋

3. PREGUNTA: Quin programa té més fils? Per què creus que hi ha aquesta diferència?

Exercici 3.3: Comparar recursos (1 punt)

1. Executa aquesta comanda per veure ambdós processos:

   ps -eLo pid,tid,pcpu,pmem,comm | grep -E "(fils01|python3)" | head -20
   

   📋

2. TASCA: Guarda la sortida:

   ps -eLo pid,tid,pcpu,pmem,comm | grep -E "(fils01|python3)" > exercici3_3.txt
   

   📋

3. PREGUNTA: Quin programa consumeix més memòria en total? (suma les columnes %MEM)

4. PREGUNTA: Quin programa és més "eficient" en termes de recursos?

Part 4: Investigació del sistema /proc (1 punt)

Exercici 4.1: Explorar /proc/PID/task (0.5 punts)

1. Llista els fils directament des de /proc:

   ls -l /proc/<PID>/task/
   

   📋

2. PREGUNTA: Quants directoris hi ha dins de task/? Coincideix amb el nombre de fils?

3. TASCA: Comprova el contingut d'un dels fils:

   cat /proc/<PID>/task/<TID>/status | head -20
   

   📋

4. PREGUNTA: Quina informació útil pots trobar en aquest fitxer?

Exercici 4.2: Informació del sistema (0.5 punts)

1. Consulta el límit màxim de fils del sistema:

   cat /proc/sys/kernel/threads-max
   

   📋

2. PREGUNTA: Quin és aquest límit al teu sistema?

3. Compta els fils totals actius al sistema:

   ps -eLf | wc -l
   

   📋

4. PREGUNTA: Quants fils hi ha actualment en execució al sistema?

Part 5: Automatització bàsica (1 punt)

Exercici 5.1: Script de monitoratge simple (1 punt)

Crea un script molt simple anomenat monitor.sh que:

1. Accepti un PID com a paràmetre
2. Mostri el nombre de fils
3. Mostri el consum de CPU i memòria total

Plantilla del script:

#!/bin/bash

# Comprovar que s'ha proporcionat un PID
if [ -z "$1" ]; then
    echo "Ús: $0 PID"
    exit 1
fi

PID=$1

# Comprovar que el procés existeix
if ! kill -0 $PID 2>/dev/null; then
    echo "Error: El procés $PID no existeix"
    exit 1
fi

# TODO: Compta el nombre de fils
# Pista: ps -p $PID -T --no-headers | wc -l

# TODO: Mostra informació de recursos
# Pista: ps -p $PID -o %cpu,%mem,comm --no-headers

echo "Monitoratge completat"

TASQUES:

1. Completa el script amb les comandes necessàries
2. Dona-li permisos d'execució: chmod +x monitor.sh
3. Executa'l: ./monitor.sh <PID>
4. Guarda el script completat com monitor.sh

Entregables

Has de lliurar els següents fitxers:

1. exercici1_2.txt - Sortida de ps -T
2. exercici1_3.txt - Sortida detallada dels fils
3. exercici1_4.txt - Sortida de pstree
4. exercici2_2.txt - Captura de top
5. exercici3_3.txt - Comparació C vs Python
6. monitor.sh - Script de monitoratge
7. respostes.txt - Fitxer amb les respostes a totes les preguntes

Format de respostes.txt

=== PRÀCTICA 4: MONITORATGE DE FILS ===

PART 1
------
Exercici 1.1
- PID: 
- Processos relacionats: 

Exercici 1.2
- Nombre de fils: 

Exercici 1.3
- TIDs: 
- Fil amb més CPU: 

Exercici 1.4
- Representació en pstree: 

PART 2
------
Exercici 2.1
- Nombre de fils en top: 
- TID amb més CPU: 

Exercici 2.2
- Percentatge CPU per fil: 
- Memòria total (RES): 

Exercici 2.3
- Els percentatges canvien?: 
- Per què?: 

PART 3
------
Exercici 3.1
- PID Python: 

Exercici 3.2
- Fils programa C: 
- Fils programa Python: 
- Diferència i motiu: 

Exercici 3.3
- Memòria total C: 
- Memòria total Python: 
- Programa més eficient: 

PART 4
------
Exercici 4.1
- Directoris en /proc/PID/task: 
- Informació útil en status: 

Exercici 4.2
- Límit threads-max: 
- Fils actius al sistema: 

PART 5
------
- Script completat i provat: Sí/No

Criteris d'avaluació

Notes importants

• No cal programar: Els programes fils01 ja estan fets, només has de monitorar-los
• Temps: Aproximadament 60-90 minuts
• Consulta: Pots consultar el document teoriaFils01.md en qualsevol moment
• Terminals: Necessitaràs almenys 2-3 terminals obertes simultàniament

Consells

1. Abans de començar, assegura't que els dos programes funcionen correctament
2. Mantén els programes executant-se mentre fas els exercicis
3. Si un programa finalitza, simplement torna a executar-lo
4. Anota els PIDs en un paper per no haver de buscar-los constantment
5. No t'amoïnis si no entens tota la sortida de les comandes, centra't en el que es demana

Extensió opcional (+1 punt extra)

Si vols aprofundir més, crea un script que:

• Monitori un procés durant X segons
• Registri el nombre de fils cada segon
• Generi un CSV amb les dades
• Calculi la mitjana, màxim i mínim de fils observats

Nom del fitxer: monitor_avançat.sh

Aquest exercici és completament opcional i no afecta la nota de la pràctica base.