ESCUELA POLITÉCNICA NACIONAL

Nombre: George Quishpe

Fecha: 24/06/2022

INFORME 3
Objetivos:
● Crear y escribir en un archivo .txt el PID del proceso padre del programa Prac_Fork_1.c.
● Comprobar que los comandos que se usan en programas shell (comandos de consola Ubuntu) no son
aplicables para programas compilados en C.
● Encontrar y analizar la información de los hilos de un proceso en un ambiente Linux.

Desarrollo de la práctica:
a. Cambio en archivo de procesos y envió a un nuevo archivo el PID del proceso.
Primero, para poder escribir en un archivo empleamos las funciones open(), write() y close() que fueron
aplicadas en el código de la práctica de Hilos. Los pasos anteriormente mencionados fueron añadidos
antes del uso de la función “fork()”. A continuación, una explicación del código:
1. Se declaró un entero “fd” que será el descriptor del fichero que vamos a abrirlo, escribirlo y cerrarlo.
Luego, creamos dos arreglos de caracteres, en “buf” irá el enunciado y en “pidPadre” irá el PID de
proceso padre, ambos serán escritos en el archivo. Con la función “snprintf()” se escribe una salida
formateada, PID padre y salto de línea, en el buffer de tamaño, en este caso “pidPadre” con 7 bytes
de tamaño.
int fd;
char buf[] = "El PID del proceso padre es: ";
char pidPadre[7];
snprintf(pidPadre, sizeof(pidPadre), "%d\n", getpid());

2. Ahora, se inicializa “fd” con la función “open()” que recibe como parámetros la ruta junto con el
nombre del archivo, los modos de como se trabajará con el archivo “O_CREAT, O_WRONLY|O_APPEND”
y los permisos “S_IWUSR|S_IRUSR” (permisos de escritura y lectura) que únicamente se añaden cuando
se usa el modo “O_CREAT” que crea un archivo en caso de no existir.

fd = open("/home/georgeq/Documentos/Practicas/Practica 3/PID_Padre.txt",O_CREAT|O_WRONLY|O_APPEND,S_IWUSR|S_IRUSR);

3. Luego, vamos a escribirlo con la función “write()” que recibe como parámetros el descriptor del
fichero “fd”, el buffer que tiene el contenido que se va a escribir en el archivo, y el tamaño del buffer
en bytes. Por último, se cierra el fichero con la función “close()” donde se envía como parámetro el
descriptor del fichero.
write(fd, buf, sizeof(buf)-1);
write(fd, pidPadre, sizeof(pidPadre)-1);
close(fd);

El código completo del archivo “Prac_Fork_1.c” modificado se encuentra en el apartado de anexos. A

partir de ahora se utilizarán dos terminales, una para ejecutar “Fork1” y otra para ver el contenido del
archivo generado.

4. Compilamos y ejecutamos el archivo:

COMANDO: gcc Prac_Fork_1.c -o fork1 Compila el programa en C y crea un
ejecutable
COMANDO: ./fork1 Ejecuta el archivo ejecutable creado
 5. En terminal 1 (izquierda) tenemos el archivo ejecutándose y en terminal 2 (derecha) está el contenido
de archivo “PID_Padre.txt”, donde se ve claramente que el PID del programa si fue escrito con éxito
sobre el archivo:

6. Si, se vuelve a ejecutar, se añadirá el PID padre de la ejecución actual, es decir:

Entonces, tendremos en el fichero los PIDs de todas las veces que se ejecutó el programa, es decir,
tendremos un registro de los PIDs de los procesos padres del programa.
b. Ejecutar archivo de hilo y reconocerlos.
1. El archivo “Pract_Thread_1.c” crea un hilo que escribe el número de líneas que enviamos como
parámetro en un archivo llamado “Hilos.txt”. Primero, se declara un variable “thread1” de tipo
“pthread_t”, luego, se usa la función “pthread_create()” que tiene como parámetros:
a. Puntero hacia el “thread1”.
b. Los atributos del hilo en este caso “NULL” para usar los atributos por defecto.
c. La rutina que ejecutará el hilo cuando se lo crea, una función “thread_routine”.
d. Los argumentos de entrada de la rutina.

2. También, se usa la función “pthread_join()” que hace que un hilo se duerma hasta que el otro hilo
termine, tiene dos parámetros, los cuales son:
a. Hilo al que queremos esperar a que se acabe de ejecutar “thread1”.
b. Un void**, en este caso “NULL”.

En el programa también se hace una verificación de que se ingrese parámetros al ejecutar el programa.
3. En la rutina se emplean funciones open(), write() y close() para manipular el archivo donde se
imprimirán el número de líneas que hemos ingresado como parámetro.
4. Compilamos y ejecutamos el archivo con:
COMANDO: gcc Pract_Thread_1.c -pthread Compila el programa en C, crea un
ejecutable predeterminado a.out
y usa la función pthread.
COMANDO: ./a.out Ejecuta el archivo ejecutable

5. Usaremos dos consolas de igual manera para ver la ejecución y el contenido del archivo “Hilos.txt”:
 Cada vez que se ejecute el programa se añadirán el número de líneas que hayamos ingresado de
parámetro.
6. Para visualizar los hilos de un programa específico usamos el comando “ps -T -p <pid>”. Usaremos
también el comando “top” para ver el PID del proceso. Por tanto, tendremos 3 terminales, la primera
(izquierda arriba) estará ejecutando el programa hasta que lo detengamos, la segunda (izquierda abajo)
muestra los hilos del programa y la tercera (derecha) muestra la información de procesos.

Como esté programa crea un solo hilo, es el único que aparece cuando ejecutamos el comando “ps -T
-p 34252”,que tiene SPID que es el PID del hilo, y el “a.out” es el comando que lo está ejecutando.
Otro comando que podemos usar para ver el árbol de hilos de un proceso es el “pstree -p <pid>” en
este caso usamos al proceso Firefox con el PID 2232:

Conclusiones:
● La manera de crear y escribir un archivo en un programa en C no se hace por medio de los comandos
del cmd, sino que, el lenguaje tiene su propia lista de librerías con funciones que a través de llamadas
al sistema ejecutan lo que se solicita.
● Un hilo es un subproceso que es más ligero que el proceso y esté mejora el tiempo de respuesta, la
compartición de recursos y permite el uso de múltiples CPU.
● El programa únicamente crea un hilo que aplica una rutina de imprimir el número de líneas que se haya
ingresado como parámetro y, para la visualización de hilos de un proceso, se encontró los comandos
“ps -T -p <pid>” que lista los hilos del proceso con información de los mismos y “pstree -p <pid>”
que muestra el árbol de hilos de un proceso.

Recomendaciones:
● Tener en cuenta que cada lenguaje de programación tiene funciones básicas similares, pero el cómo
implementarlas ya depende del lenguaje.
 ● Saber qué hace cada función usada en los programas porque en caso de que ocurra un fallo al modificar
un código se nos hará más fácil arreglar el problema.
● Añadir código en el lugar adecuado, de modo que, el programa haga justo lo que solicite, nada más y
nada menos que eso.
Anexos:
Prac_Fork_1.c
El código de otro color y en negrita es el texto añadido a “Prac_Fork_1.c” donde se abre, escribe, PID de
proceso padre, y cierra un archivo con el nombre “PID_Padre.txt”.
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>

int var = 22;

int main(void)
{
pid_t pidC; // valor del sistema; identificador de proceso PID
printf("** proc. PID = %d comienza ** \n", getpid());

int fd;
char buf[] = "El PID del proceso padre es: ";
char pidPadre[7];
snprintf(pidPadre, sizeof(pidPadre), "%d\n", getpid());
fd = open("/home/georgeq/Documentos/Practicas/Practica 3/PID_Padre.txt",O_CREAT|O_WRONLY|O_APPEND,S_IWUSR|S_IRUSR);
write(fd, buf, sizeof(buf)-1);
write(fd, pidPadre, sizeof(pidPadre)-1);
close(fd);

pidC = fork(); /*Process ID de hijo*/

printf("Proceso PID = %d, pidC = %d ejecutandose, Valor = %d \n", getpid(), pidC, var);
if(pidC > 0) /*Aquí se ejecuta el proceso padre*/
{
var = 44; /*Proceso padre*/
}

else if(pidC == 0)
{
var = 33; /*Proceso hijo*/
}else /* error */
{
}
while(1) /*esto lo ejecuta el padre y el hijo*/
{
sleep(2);
printf("** Proceso PID = %d, var = %d ejecutandose ** \n", getpid(), var);
}
return 0;
}

Pract_Thread_1.c

#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

void *thread_routine(void *arg)

{
int nr_lines = *((int*)arg);
int fd;
char buf[] = "Nueva linea \n";

printf("El hilo comienza a ejecutarse.....\n");

for(int i = 0; i< nr_lines; i++)

{
fd = open("/home/georgeq/Documentos/Practicas/Practica 3/Hilos.txt",O_CREAT|O_WRONLY|O_APPEND,S_IWUSR|S_IRUSR);
write(fd, buf, sizeof(buf)-1);
close(fd);
}

}
int main(int argc, char *argv[])
{
pthread_t thread1;
 int value = 0;
if(argc > 1)
{
value = atoi(argv[1]);
}
else
{
printf("Favor ingresar el argumento(# de lineas)....\n");
}
if(0 != pthread_create(&thread1, NULL, thread_routine, &value))
return -1;
pthread_join(thread1, NULL);
while(1){
}
return 0;
}