Resumen

Generalmente se encuentran diferencias entre lo que dice la teoría versus lo que se encuentra
en la práctica. Los sistemas operativos, por ejemplo, es un área de mucha actividad e
innovación porque constantemente se está pensando en el desarrollo cada vez más eficiente
de sistemas que respondan de mejor manera a las necesidades de usuarios, servicios y en
general de procesos dentro de un sistema. La teoría presenta unos lineamientos pero la
práctica y la observación del desempeño de los sistemas permite a los desarrolladores y
administradores darse ciertas libertades que les permiten conseguir sistemas más eficientes y
no necesariamente apegados a lo que indica la teoría. Uno de estos temas es el de los
procesos y los hilos de ejecución. En este documento se dará una descripción de cómo los
procesos y los hilos se relacionan en los sistemas basados en Linux.

Tabla de contenido
1. Puntos a considerar 2

2. Preguntas 3

3. Realidad [en sistemas Linux] 4

4. Demostración en Linux 5

5. Comentarios 6

6. ¿Por qué para el programa que se planteó como medio para comparar el rendimiento
de procesos e hilos, los procesos sistemáticamente se comportan mejor que los hilos? 7
6.1. Llamadas al sistema 7
1. Puntos a considerar
● Los procesos son la abstracción del sistema operativo que le permite a los usuarios y a
las aplicaciones hacer uso de la CPU.
● La teoría sugiere que el sistema operativo asigna procesos a la CPU. Es decir, por cada
CPU hay un posible proceso en ejecución.
● Los procesos son entidades de ejecución que no comparten nada entre los procesos. Si
dos o más procesos quieren intercambiar información deben usar algún mecanismo de
IPC (inter process communication) provisto por el sistema operativo.
● Los hilos de ejecución son conocidos como procesos livianos y forman parte de un
proceso. Los hilos de ejecución en un proceso son capaces de compartir información
con otros hilos pertenecientes al mismo proceso a través de variables compartidas en
memoria RAM.
● La única forma de aprovechar los sistemas multicore, que constan de n núcleos, es
cuando se logra programar con hilos. De otra forma el sistema operativo asignará un
proceso a la CPU y n - 1 núcleos quedarán subutilizados.
2. Preguntas
● ¿Si no se programa con hilos el programa será menos eficiente cuando este se ejecute
en sistemas basados en múltiples núcleos?
● ¿Es más rápido ejecutar una tarea computacional cuando se ejecuta en un programa
con varios hilos (e.g. N hilos) que ejecutar la misma aplicación con varios procesos (e.g.
N procesos)?
3. Realidad [en sistemas Linux]
● Los sistemas operativos son programas de computador que deben ser eficientes en el
manejo de los recursos, incluso la CPU.
● Sistemas basados en Unix tienen una larga trayectoria y en la actualidad muchas de sus
implementaciones tienen unos altos niveles de madurez.
● La definición de un proceso se encuentra en el archivo include/linux/sched.h en la
estructura task_struct.
○ La descripción del proceso actual en ejecución se puede conocer a través de la
macro current. La macro get_current() devuelve un apuntador de tipo
task_struct.
○ En sistemas de múltiples núcleos o múltiples CPUs, cada uno tiene su propia
referencia a un task_struct y representa el proceso que se está ejecutando en
esa CPU o núcleo.
● La creación de procesos en Linux se hace a través de la llamada al sistema fork() o
clone().
○ Una vez se crea un proceso pocos datos son alterados del task_struct del
nuevo proceso. Entre los ítems que se alteran se tienen: pid y ppid, entre otros.
○ La implementación del sistema operativo no hace una copia inmediatamente de
toda la información del nuevo proceso sino que usa una técnica llamada
copy-on-write. Al momento de haber modificaciones de parte del nuevo proceso
es que se hace efectivamente la copia de los datos del nuevo proceso.
● Los hilos en Linux no tienen un concepto que los distinga claramente de los procesos.
○ En otros sistemas, a los hilos se les conoce como procesos ligeros y se debe
fundamentalmente al tiempo que toma crear un hilo versus un proceso, el cual
es más demorado en este último.
○ En Linux los hilos se diferencian de los procesos en que los primeros son
capaces de compartir recursos del espacio de direcciones de su padre.
○ De hecho, los hilos usan la función clone() la cual se usa también para crear los
procesos.
● El kernel de Linux hace una asociación entre un hilo de usuario con un hilo del kernel.
4. Demostración en Linux
● Se usará una máquina virtual
○ Sistema operativo Linux, Ubuntu Xenial 64.
○ Cuatro núcleos.
○ Cuatro gigabytes en RAM.
● Se usará una aplicación intensiva en cómputo
○ Fibonacci recursivo
int fibo(int n) {
if (n == 0) return 0;
if (n == 1) return 1;
return fibo(n - 1) + fibo(n - 2);
}
int tiempofibo(int f) {
tiempo inicial, final;
int _f;
inicial = start();
_f = fibo(f);
final = stop();
printf("[%d] Calculando el fibo de %d tomo %lf segundos. Valor
%d\n",getpid(),f,transcurrido(inicial,final), _f);
return _f;
}

○ fibofork.c
for (i = 0; i < processes; i++) {
int id = fork();
if (id == 0) {
tiempofibo(_fibo);
return 0;
}
}
for (i = 0; i < processes; i++) {
int pid = wait(NULL);
printf("Termino proceso %d (%d/%d)\n",pid,i + 1, processes);
}

○ fibothreads.c
void *worker(void *arg) {
int *valor = arg;
struct timeval t0, t1, dt;
gettimeofday(&t0,NULL);
fibo(*valor);
gettimeofday(&t1,NULL);
timersub(&t1, &t0, &dt);
printf("Tiempo transcurrido en hilo (%ld) fue %ld.%06ld
sec\n",(long)pthread_self(), dt.tv_sec, dt.tv_usec);

return NULL;
}
//--- int main()
for (i = 0; i < totalhilos; i++)
pthread_create(&hilos[i],NULL, worker, &_fibo);
for (i = 0; i < totalhilos; i++)
pthread_join(hilos[i], NULL);
 ○ Tiempos de ejecución.
Ambiente Ejecución 1(s) Ejecución 2(s) Ejecución 3(s) Promedio(s)

fork 7.218 7.199 7.197 7.205

pthread 7.998 8.021 7.961 7.993

5. Comentarios
● Procesos e hilos tienen tiempos de ejecución muy similares.
● Se deben validar otro tipo de experimentos y/o escenarios:
○ Tareas intensivas en E/S.
○ Tareas colaborativas (comparten información en tiempo de ejecución)
● ¿Por qué correr con procesos sistemáticamente es más efectivo que correr con hilos
este programa en particular?
6. ¿Por qué para el programa que se planteó como
medio para comparar el rendimiento de procesos e
hilos, los procesos sistemáticamente se comportan
mejor que los hilos?
Durante la evaluación de los dos programas los cuales hacían la misma tarea solo que uno la
llevaba a cabo con hilos y la otra con procesos, se evidenció un mejor rendimiento en todos los
casos por parte de la implementación basada en procesos. ¿Por qué sucedió esto? Se
comenzarán a estudiar varias razones:
● Llamadas al sistema
6.1. Llamadas al sistema
Para validar si la diferencia se encontraba en las llamadas al sistema, se decidió usar el
programa strace1. El programa strace permite determinar cuántas llamadas al sistema realizó
un programa durante su ejecución. De esta forma se validó la ejecución de los aplicativos:

strace -S name -c ./fibofork

strace -S name -c ./fibothreads

1
Esta información se tomó del recurso diseñado por el profesor Julián Gutiérrez de la Universidad del
Quindío (jugutier@uniquindio.edu.co). Link al recursos:
https://docs.google.com/presentation/d/16OIL3AqZHb_o7JaXFnUjCGIl_dfgP87mMBhnNtDC4Nk/edit?usp
=sharing
El número de llamadas al sistema estuvo casi siempre constante. Para fibofork 40 llamadas al
sistema y para fibothreads 57, 58 o 59. Hay dos llamadas al sistema que llaman la atención
wait4 en fibofork y futex en fibothreads. La razón fundamental es porque el tiempo
invertido en esas llamadas varía de ejecución en ejecución. Algunas veces no se demora nada
y otras veces se observan valores tales como: 4000, 12000, 2000 microsegundos/llamada para
futex. Para wait4 los valores obtenidos pueden ser: 0, 1000, 5000 microsegundos por llamada.
Lo único medianamente constante es el número de llamadas al sistema 40 al ejecutar fibofork
o entre 57 y 59 llamadas al sistema para fibothreads.

En conclusión se puede decir:

● Las llamadas al sistema son en mayor número las de fibothreads que en fibofork con
un valor superior a 17 llamadas que corresponden al 42% del total de llamadas que se
hacen en fibofork.
● Las llamadas al sistema que más invocaciones se presentan en fibofork son: mmap con
7 llamadas y con 4 llamadas: clone, mprotect, wait y write.
● En fibothreads las llamadas al sistema más requeridas fueron: mmap con 15, mprotect
con 10 y con 4 access y clone.
● Este resultado también nos deja ver que para crear hilos y procesos se usa la llamada al
sistema clone.