Práctica 7
Octubre 2017
/* Hilos */
Un hilo es una unidad básica de utilización del CP U, com prende de un I D de
hilo, un contador de program a, un conjunto de registros y una pila.
Com parte con otros hilos que pertenecen al m ism o proceso la sección de
código, la sección de datos y otros recursos del sistem a operativo, com o los
archivos abiertos y las señales.
P ara ejem plificar el uso de hilos en lenguaje C, a continuación se m uestra el
código para que un hilo corra concurrentem ente al proceso padre, debido al
uso de la función ‘ usleep(1);’ el proceso padre y el hilo conm utan
alternativam ente el uso del procesador increm entando la variable ‘i’ hasta
culm inar.
Observe que la función “ void *hilo(void *arg)” es convertida en hilo y se pasa
su argum ento al m ism o tiem po adjunto a la función en la llam ada al sistem a
“ pthread_create()” , com o se puede constatar en el código:
// hilosb.c
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
/* Esta es la funcion thread function. es como main(), pero para 'thread' */
void *hilo(void *arg)
{
char *str;
int i = 50;
int MIN=0;
str=(char*)arg;
while(i > MIN )
{
usleep(1);
printf("\t\t\t\tel hilo dice: %s %d\n",str,i);
--i;
}
return NULL;
}
int main(void){
pthread_t pth; // Este es nuestro identificador del hilo (thread)
int i = 0,MAX1=50;
char *cadena="ESIME Culhuacan";
pthread_create(&pth,NULL,hilo,cadena);
while(i < MAX1)
{
usleep(2);
Práctica 7
Octubre 2017
printf("main esta ejecutandose...%d\n",i);
++i;
}
printf("\t\t main espera a que termine el hilo (thread)...\n");
pthread_join(pth,NULL);
return 0;
}
Este ejem plo increm enta un contador de la m ism a form a el proceso padre que
el hilo y lo reporta el proceso padre ‘dividiendo la tarea’:
/ / increm enta.c
/* http://timmurphy.org/2010/05/04/pthreads-in-c-a-minimal-working-example/ abril 2016 */
#include <pthread.h>
#include <stdio.h>
void *inc_x(void *x_void_ptr) /* esta funcion es ejecutada por el hilo */
{
int *x_ptr = (int *)x_void_ptr;
while(++(*x_ptr) < 100); /* incrementa x a 100 */
printf("x incremento terminado en el hilo\n");
return NULL; /* La funcion debe regresar algo - NULL es correcto */
}
int main()
{
int x = 0, y = 0;
printf("x: %d, y: %d\n", x, y);
/* Muestra los valores iniciales de 'x' y 'y'*/
pthread_t x_thread;
/* esta variable es nuestra referencia al hilo 'x_thread' */
if(pthread_create(&x_thread, NULL, inc_x, &x)) {
/* creamos el hilo que ejecuta inc_x(&x) */
fprintf(stderr, "Error creando el hilo \n");
return 1;
}
while(++y < 100); /* incrementamos y a 100 en el primer hilo */
printf("y incremento terminado en el proceso \n");
if(pthread_join(x_thread, NULL)) {
/* esperamos a que termine el segundo hilo */
fprintf(stderr, "Error esperando al hilo\n");
return 2;
}
printf("x: %d, y: %d\n", x, y);
/* muestra los resultados - x es igual a 100 gracias al segundo hilo */
return 0;
}
Práctica 7
Octubre 2017
El siguiente es un ejem plo del libro para verificar la operación de hilos
// Operating System Concepts, Silverschatz, Baer Galvin & Gagne, 9 Ed.
// Figure 4.9 Multithreaded C program using the Pthreads API.
// Seccion 4.4 Thread Libraries pag 173
// runner.c
#include <pthread.h>
#include <stdio.h>
int sum; /* this data is shared by the thread(s) */
void *runner(void *param); /* threads call this function */
int main(int argc, char *argv[]){
pthread_t tid; /* the thread identifier */
pthread_attr_t attr; /* set of thread attributes */
if (argc != 2) {
fprintf(stderr,"usage: a.out <integer value>\n");
return -1;
}
if (atoi(argv[1]) < 0) {
fprintf(stderr,"%d must be >= 0\n",atoi(argv[1]));
return -1;
}
/* get the default attributes */
pthread_attr_init(&attr);
/* create the thread */
pthread_create(&tid,&attr,runner,argv[1]);
/* wait for the thread to exit */
pthread_join(tid,NULL);
printf("sum = %d\n",sum);
}
/* The thread will begin control in this function */
void *runner(void *param){
int i, upper = atoi(param); /* Observe que '*param' es usado
para pasar datos entre main y runner */
sum = 0;
for (i = 1; i <= upper; i++)
sum += i;
pthread_exit(0);
}
Práctica 7
Octubre 2017
El siguiente es el código para solicitar al sistem a operativo espacios de
m em oria que para propósitos de la práctica se solicitan en m últiplos de
M egabytes y son llenados aleatoriam ente de caracteres alfabéticos (a-z).
Verifique el funcionam iento del program a ejecutándolo para 10, 100 y 1000 M B
y redirija la salida a un archivo para verificar el tam año de espacios que son
solicitados y llenados.
// buffer.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define MB 1024*1024
int megabytes = 0;
int to_Mbytes(int bytes){ // convierte de bytes a megabytes
return bytes * MB;
}
int main(int argc, char *argv[]){
int i;
char *buffer;
int bytes;
if(argc!=2) {
printf("Uso: %s <entero>\n %s reserva memoria en MB por el valor de
<entero>\n", argv[0],argv[0]);
exit(1);
}
printf("Tamaño de la memoria a reservar:%s\n",argv[1]); sleep(3);
bytes=atoi(argv[1]);
megabytes = to_Mbytes(bytes); // convierte a entero el segundo parámetro
buffer = (char*) malloc(megabytes+1); //reserva la memoria
if (buffer == NULL) exit(EXIT_FAILURE); // si hay un problema con el buffer,
termina el programa
for (i=0; i<megabytes; i++) // llena el buffer aleatoriamente de
buffer[i] = rand() % 26 + 'a'; // letras minúsculas del alfabeto
buffer[bytes]='\0'; // al termino del buffer coloca fin de línea
printf("Cadena aleatoria en buffer: %s\n", buffer);
// imprime a pantalla el contenido del buffer
free (buffer); // libera la memoria del buffer
exit(EXIT_SUCCESS); // termina bien el programa
}
Práctica 7
Octubre 2017
A djunto a esta práctica se anexan los archivos con los códigos
correspondientes para los ejem plos previos, verifique el funcionam iento
com pilándolos y ejecutándolos cada uno.
Sugerencia:
En Linux deberá com pilar los códigos integrando la librería ‘lpthread’ com o a
continuación:
$ cc th_hilos.c –o hilos.out –lpthread
Use la llam ada al sistem a fork() y pthread_create() para crear procesos e hilos,
de m anera que el proceso hijo/ hilo genere los espacios de m em oria de acuerdo
al código del archivo buffer.c
Deberán entregarse:
a) Código para crear un proceso hijo que genere espacios de m em oria
(buffer) en m últiplos de 1 M B
b) Código para crear un hil que genere espacios de m em oria (buffer) en
m últiplos de 1 M B.
c) Finalm ente, se anexa un archivo con la m ultiplicación de m atrices en un
código con un solo proceso, observe que el código lee de un archivo
denom inado ‘datos_m A B.txt’ los datos de las m atrices A y B y deja el
resultado de la m ultiplicación en un archivo denom inado
‘resultado_m A xB.txt’.
Divida en hilos de acuerdo a lo siguiente:
• Un hilo generará aleatoriam ente los datos de la m atrices A y B.
• Otro hilo hará la m ultiplicación de las m atrices
• Otro hilo m ostrará las m atrices A y B y la resultante C= A xB
• Entregar el código del program a de m ultiplicación de m atrices usando
hilos, adem ás del resultado para un ejem plo de m ultiplicación de las
m atrices de 10 X 10. Deberá m odificarse el archivo de datos para la
lectura de cada una de las m atríces de 10X10. La prim era línea de
datos debe corresponder con la boleta.
Checar:
http:/ / softpixel.com / ~cw right/ program m ing/ threads/
