Guía de Laboratorio 5

UNIVERSIDAD NACIONAL DE SAN AGUSTIN
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS

ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMA
Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Aprobación: 2022/03/01 Código: GUIA-PRLD-001 Página: 1
GUÍA DE LABORATORIO
INFORMACIÓN BÁSICA
ASIGNATURA: Sistemas Operativos

TÍTULO DE LA
Programación de colas de mensajes
PRÁCTICA:
NÚMERO DE NRO.
5 AÑO LECTIVO: 2023 B
PRÁCTICA: SEMESTRE:
INDIVIDUAL
TIPO DE X
PRÁCTICA: MÍNIMO DE MÁXIMO DE
GRUPAL 10 15
ESTUDIANTES ESTUDIANTES
FECHA INICIO: 09/10/2023 FECHA FIN: 15/10/2023 DURACIÓN: 2 horas
RECURSOS Y EQUIPOS A UTILIZAR:
Ubuntu Linux, gcc, Computador personal, lapiz, papel
DOCENTE(s):
Msc Roni Guillermo Apaza Aceituno
OBJETIVOS/TEMAS Y COMPETENCIAS
OBJETIVOS:
- Utilizar las funciones para comunicación entre procesos usando colas de mensajes
- Conocer el uso de colas de mensajes para la comunicación entre procesos en Linux
TEMAS:
• Uso de colas de mensajes para comunicación entre procesos
• Uso de programación concurrente para comunicación entre procesos
COMPETENCIAS C.a Aplica de forma transformadora conocimientos de matemática, computación e

A ALCANZAR ingeniería como herramienta para evaluar, sintetizar y usar las estrategias implementadas
por los Sistemas Operativos como fundamento de sus ideas y perspectivas para la
resolución de problemas.

CONTENIDO DE LA GUÍA
I. MARCO CONCEPTUAL
Teoría de Colas de Mensajes
Cada proceso puede crear una o más estructuras llamadas colas; Cada estructura puede esperar uno o más
mensajes de diferentes tipos, que pueden venir de diferentes fuentes y pueden contener información de toda
naturaleza; todos pueden enviar un mensaje a las colas de las cuales conozcan su identificador. Los procesos
pueden acceder secuencialmente a la cola, leyendo los mensajes en orden cronológico (desde el más antiguo,
el primero, al más reciente, el último en llegar), pero selectivamente, esto es, considerando sólo los mensajes
de un cierto tipo: esta última característica nos da un tipo de control de la prioridad sobre los mensajes que
leemos.
El uso de las colas es similar a una implementación simple de un sistema de correo: cada proceso tiene una
dirección con la cual puede operar con otros procesos. El proceso puede entonces leer los mensajes
mandados a su dirección en un orden preferencial y actuando de acuerdo con lo que le ha sido notificado.
Antes de que podamos implementar el lenguaje C las colas de mensajes es necesario hablar sobre otro
problema relativo a la sincronización: la necesidad de un protocolo de comunicación.
Creando un protocolo
Un protocolo es un conjunto de reglas que controlan la interacción de los elementos en un conjunto. El uso de
las colas de mensajes nos permite implementar protocolos más complejos: es suficiente pensar que cada
protocolo de red (TCP/IP, DNS, SMTP, ...) está construido con una arquitectura de intercambio de mensajes,
incluso si la comunicación es entre ordenadores y no interna en uno de ellos. La comparación es compulsiva:
no hay ninguna diferencia real entre comunicación entre procesos en la misma máquina y comunicación
entre procesos entre distintas máquinas.
Este es un ejemplo sencillo de protocolo basado en intercambio de mensajes: dos procesos A y B se ejecutan
concurrentemente y procesan diferentes datos; una vez terminados sus procesos tienen que mezclar sus
resultados. Un protocolo simple para dirigir esta interacción puede ser el siguiente:
PROCESO B:
Trabaja con tus datos
Cuando termines mándale un mensaje a A
Cuando A responda empieza a enviarle tus resultados.
PROCESO A:
Trabaja con tus datos
Espera un mensaje de B
Responde al mensaje
Recibe los datos y mezclalos con los tuyos

Elegir qué proceso tiene que mezclar los datos es en este caso totalmente arbitrario; lo más común es que
esto se haga en función de la naturaleza de los procesos envueltos (cliente/servidor)
Este protocolo es sencillamente extensible al caso de n procesos : cada proceso menos A trabaja con sus
propios datos y luego envía un mensaje a A. Caundo A responde cada proceso le manda sus resultados: la
estructura del proceso individual (excepto A) no es modificada.
Colas de Mensajes System V

Ahora es el momento de hablar sobre la implementación de estos conceptos en el sistema operativo Linux.
Como ya he dicho tenemos una serie de primitivas que nos permiten manejar las estructuras relativas a las
colas de mensajes y que trabajan como estas para manejar semáforos: Así que voy a asumir que el lector
conoce los conceptos básicos relativos a la creación de procesos, uso de las llamadas del sistema y las llaves
IPC.
La estructura base del sistema que describe un mensaje se llama msgbuf ; y está declarada en linux/msg.h
/* message buffer for msgsnd and msgrcv calls */

struct msgbuf {
long mtype; /* type of message */
char mtext[1]; /* message text */
};
El campo mtype representa el tipo de mensaje y es un número estrictamente positivo: la correspondencia

entre números y tipos de mensajes ha de ser establecida a priori y forma parte de la definición del protocolo.
El segundo campo representa el contenido del mensaje, pero no ha de ser considerado en la declaración. La
estructura msgbuf puede ser redefinida así que puede contener datos complejos; por ejemplo, es posible
escribir:
struct message {
long mtype; /* message type */
long sender; /* sender id */
long receiver; /* receiver id */
struct info data; /* message content */
...
};
Antes de enfrentarnos a los argumentos estrictamente relacionados con la teoría de la concurrencia

debemos considerar crear el prototipo de un mensaje con el tamaño máximo, fijado a 4056 bytes.
Obviamente siempre es posible recompilar el kernel incrementando esta dimensión, pero hace que la
aplicación no sea portable (es más, éste ha sido fijado para garantizar un buen rendimiento e incrementarlo
no va a ser buena idea)
Para crear una nueva cola un proceso debe llamar a la función msgget()
int msgget(key_t key, int msgflg)

que recibe como argumente una llave IPC y algunos flags (banderas), que por ahora pueden ser puestos a:
IPC_CREAT | 0660

(crea la cola, si no existe, y da acceso al propietario y grupo de usuarios), y este devuelve el identificador de
la cola.
Para enviar un mensaje a una cola de la cual conozcamos us identificador, tenemos que utilizar la función
msgsnd()
int msgsnd(int msqid, struct msgbuf *msgp, int msgsz, int msgflg)
Donde msqid es el identificador de la cola, msgp es un puntero al mensaje que tenemos que enviar (cuyo tipo
es aquí definido como struct msgbuf pero que es el tipo que redefinimos), msgsz la dimensión del mensaje
(excluyendo la longitud del tipo mtype que tiene la longitud de un long, que es normalmente de 4 bytes) y
msgflg un flag relativo a la política de espera. La longitud del mensaje puede ser facilmente encontrada
como
length = sizeof(struct message) - sizeof(long);
mientras la política de espera se refiere al caso de la cola completa: si msgflg es puesta a IPC_NOWAIT el
proceso emisor no esperará mientras no haya algún espacio disponible y saldrá con algún código de error ;
hablaremos sobre cada caso cuando hablemos del tratamiento de errores.
Para leer los mensjaes contenidos en una cola utilizamos la llamada del sistema msgrcv()
int msgrcv(int msqid, struct msgbuf *msgp, int msgsz, long mtype, int msgflg)
Donde el puntero msgp identifica el búffer donde copiaremos el mensaje leido de la cola y mtype identica el
subconjunto de mensajes que queremos considerar.
Se puede eliminar una cola a través del uso de la primitiva msgctl() con el flag IPC_RMID
msgctl(qid, IPC_RMID, 0)
II. EJERCICIO RESUELTO

Ejercicio 1.
Crear el siguiente programa en c, que hace referencia a un programa que escribe, llamelo crea.c, compilelo:
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
struct Msm {
long mtype;
int litros;
}Msm;
void enviarDatos(int msgid, long tipo){

struct Msm msm;
msm.mtype=tipo;
int i;
for (i = 0; i < 10; ++i) {

msm.litros = 10000*i;
msgsnd(msgid,&msm,sizeof(Msm)-sizeof(long),IPC_NOWAIT);
}
}
int main(int argc, const char *argv[])

{
//crear
key_t clave = ftok("/temp",40);
int msgid = msgget(clave,IPC_CREAT|0660);
//envia datos
enviarDatos(msgid, 1);
enviarDatos(msgid, 2);
//
char buffer[12];
scanf("%s",buffer);
//liberar
msgctl(msgid,IPC_RMID,NULL);
return 0;
}
Para compilar este programa utilizamos el siguiente comando en línea de comandos
$ gcc -w crear.c -o crear
Ejercicio 2.
Crear el siguiente programa en c, que hace referencia a un programa que escribe, llamelo leer.c, compilelo:
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
struct Msm {
long mtype;
int litros;
}Msm;
void leerDatos(int msgid,long tipo){

struct Msm msm;
int i;
for (i = 0; i < 10; ++i) {
msgrcv(msgid,&msm,sizeof(msm)-sizeof(long),tipo,0);

printf("tipo mensaje: [%ld] litros: [%d]\n",msm.mtype,msm.litros);

}
int main(int argc, const char *argv[])

{
//crear
key_t clave = ftok("/temp",40);
int msgid = msgget(clave,0660);
if(msgid<0){
perror("error en cola\n");exit(1);}
//envia datos
leerDatos(msgid, 2);
leerDatos(msgid, 1);
return 0;
}
$ gcc -w leer.c -o leer
Ejercicio 3.
Crear el siguiente programa en c, que hace referencia a un programa que escribe, llamelo writer.c, compílelo
// Programa en C para la cola de mensajes (proceso que escribe)

#include <stdio.h>
#define MAX 10
// Estructura para la cola de mensajes

struct mesg_buffer {
long mesg_type;
char mesg_text[100];
} message;
int main()
{
key_t key;
int msgid;
// ftok genera la clave unica

key = ftok("progfile", 65);
// msgget crea una cola de mensajes


// y retorna el identificador
msgid = msgget(key, 0666 | IPC_CREAT);
message.mesg_type = 1;
printf("Escribe datos : ");

fgets(message.mesg_text,MAX,stdin);
// msgsnd envia mensajes

msgsnd(msgid, &message, sizeof(message), 0);
// display the message

printf("Los datos enviados son : %s \n", message.mesg_text);
return 0;
}
$ gcc writer.c -o writer
Ejercicio 4.
Crear el siguiente programa en c, que hace referencia a un programa que escribe, llamelo reader.c, compílelo
// Programa en para la cola de mensajes (proceso lector)

#include <stdio.h>
// Estructura para la cola de mensajes

struct mesg_buffer {
long mesg_type;
char mesg_text[100];
} message;
int main()
{
key_t key;
int msgid;
// ftok para generar la clave unica

key = ftok("progfile", 65);
// msgget para crear un cola de mensajes

// y retorna el identificador
msgid = msgget(key, 0666 | IPC_CREAT);
// msgrcv para recibir el mensaje


msgrcv(msgid, &message, sizeof(message), 1, 0);
// muestre el mensajedisplay the message

printf("Los datos recibidos son : %s \n",
message.mesg_text);
// Para destruir la cola de mensajes

msgctl(msgid, IPC_RMID, NULL);
return 0;
}
$ gcc reader.c -o reader
Ejercicio 5.
Crear el siguiente programa en c, que hace referencia a un programa que escribe, llamelo msgg_send.c,
compílelo
/* Nombre de archivo: msgq_send.c */

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#define PERMS 0644

struct my_msgbuf {
long mtype;
char mtext[200];
};
int main(void) {
struct my_msgbuf buf;
int msqid;
int len;
key_t key;
system("touch msgq.txt");
if ((key = ftok("msgq.txt", 'B')) == -1) {

perror("ftok");
exit(1);
}

if ((msqid = msgget(key, PERMS | IPC_CREAT)) == -1) {

perror("msgget");
exit(1);
}
printf("cola de mensajes: lista para enviar mensajes.\n");
printf("Ingrue la linea de texto, ^D ^para salir:\n");
buf.mtype = 1; /* No nos importa este caso en realidad */
while(fgets(buf.mtext, sizeof buf.mtext, stdin) != NULL) {

len = strlen(buf.mtext);
/*remueve newline al final si esta existe */
if (buf.mtext[len-1] == '\n') buf.mtext[len-1] = '\0';
if (msgsnd(msqid, &buf, len+1, 0) == -1) /* +1 for '\0' */
perror("msgsnd");
}
strcpy(buf.mtext, "end");
len = strlen(buf.mtext);
if (msgsnd(msqid, &buf, len+1, 0) == -1) /* +1 for '\0' */
perror("msgsnd");
if (msgctl(msqid, IPC_RMID, NULL) == -1) {

perror("msgctl");
exit(1);
}
printf("cola de mensajes hecha enviando mensajes.\n");
return 0;
}
$ gcc msgg_send.c -o msgg_send
Ejercicio 6.
Crear el siguiente programa en c, que hace referencia a un programa que escribe, llamelo msgq_recv.c,
compílelo
/* Nombre de archivo: msgq_recv.c */

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#define PERMS 0644

struct my_msgbuf {

long mtype;
char mtext[200];
};
int main(void) {
struct my_msgbuf buf;
int msqid;
int toend;
key_t key;
if ((key = ftok("msgq.txt", 'B')) == -1) {

perror("ftok");
exit(1);
}
if ((msqid = msgget(key, PERMS)) == -1) { /* conectando con la cola */

perror("msgget");
exit(1);
}
printf("cola de mensajes lista para recibir mensajes.\n");
for(;;) { /* normalmente la recepción nunca termina pero tiene una conclusion */

/* este programa finaliz con la cadena end */
if (msgrcv(msqid, &buf, sizeof(buf.mtext), 0, 0) == -1) {
perror("msgrcv");
exit(1);
}
printf("recvd: \"%s\"\n", buf.mtext);
toend = strcmp(buf.mtext,"end");
if (toend == 0)
break;
}
printf("cola de mensajes hecha recibiendo mensajes.\n");
system("rm msgq.txt");
return 0;
}
$ gcc msgq_recv.c -o msgq_recv
Ejercicio 7
Crear el siguiente programa en c, que hace referencia a un programa que escribe, llamelo elqueenvia.c,
compílelo
#include <stdio.h>
#include <stdlib.h>

#include <linux/ipc.h>
#include <linux/msg.h>
/* Redefiniendo la estructura msgbuf */

typedef struct mymsgbuf
{
long mtype;
int int_num;
float float_num;
char ch;
} mess_t;
int main()
{
int qid;
key_t msgkey;
mess_t sent;
mess_t received;
int length;
/* Inicialice la semilla del generador del número pseudo random */

srand (time (0));
/* Longitud el mensaje */
length = sizeof(mess_t) - sizeof(long);
msgkey = ftok(".",'m');
/* Crea la cola */
qid = msgget(msgkey, IPC_CREAT | 0660);
printf("QID = %d\n", qid);
/* Construye el mensaje */
sent.mtype = 1;
sent.int_num = rand();
sent.float_num = (float)(rand())/3;
sent.ch = 'f';
/* Envia el mensaje */
msgsnd(qid, &sent, length, 0);
printf("MENSAJE ENVIADO...\n");
/* Recibe el mensaje */
msgrcv(qid, &received, length, sent.mtype, 0);

printf("MENSAJE RECIBIDO...\n");
/* Controla que lo que se ha recibido sea igual a lo que se ha enviado */

printf("Numero entero = %d (sent %d) -- ", received.int_num,
sent.int_num);
if(received.int_num == sent.int_num) printf(" OK\n");
else printf("ERROR\n");
printf("Numero flotante = %f (sent %f) -- ", received.float_num,

sent.float_num);
if(received.float_num == sent.float_num) printf(" OK\n");
printf("Char = %c (sent %c) -- ", received.ch, sent.ch);

if(received.ch == sent.ch) printf(" OK\n");
/* Estruye la cola */
msgctl(qid, IPC_RMID, 0);
}
Para compilar este programa utilizamos el siguiente comando en linea de comandos
$ gcc elqueenvia.c -o elqueenvia
Ejercicio 8.
Crear el siguiente programa en c, que hace referencia a un programa que escribe, llamelo elquerecibe.c,
compílelo
#include <stdio.h>
#include <stdlib.h>
#include <linux/ipc.h>
#include <linux/msg.h>
/* Redefine la estructura del mensaje */

typedef struct mymsgbuf
{
long mtype;
int num;
} mess_t;
int main()
{
int qid;
key_t msgkey;
pid_t pid;

mess_t buf;
int length;
int cont;
length = sizeof(mess_t) - sizeof(long);
msgkey = ftok(".",'m');
qid = msgget(msgkey, IPC_CREAT | 0660);
if(!(pid = fork())){
printf("HIJO - QID = %d\n", qid);
srand (time (0));
for(cont = 0; cont < 10; cont++){

sleep (rand()%4);
buf.mtype = 1;
buf.num = rand()%100;
msgsnd(qid, &buf, length, 0);
printf("HIJO – NUMERO DE MENSAJE %d: %d\n", cont+1, buf.num);
}
return 0;
}
printf("PADRE - QID = %d\n", qid);
for(cont = 0; cont < 10; cont++){

sleep (rand()%4);
msgrcv(qid, &buf, length, 1, 0);
printf("PADRE – NUMERO DE MENSAJE %d: %d\n", cont+1, buf.num);
}
msgctl(qid, IPC_RMID, 0);
return 0;
}
$ gcc elquerecibe.c -o elquerecibe
Ejercicio 9

Crear el siguiente programa en c, que hace referencia a un programa que escribe, llamelo message_send.c,
compílelo
#include <stdio.h>
#include <string.h>
#define MSGSZ 128
/*
* Declara la estructura del mensaje.
*/
typedef struct msgbuf {

long mtype;
char mtext[MSGSZ];
} message_buf;
main()
{
int msqid;
int msgflg = IPC_CREAT | 0666;
key_t key;
message_buf sbuf;
size_t buf_length;
/*
* Consigue el id de la cola de mensaje para el
* "name" 1234, el cual ha sido creado
* por el servidor.
*/
key = 1234;
(void) fprintf(stderr, "\nmsgget: llamando a msgget(%#lx,\

%#o)\n",
key, msgflg);
if ((msqid = msgget(key, msgflg )) < 0) {

perror("msgget");
exit(1);
}
else
(void) fprintf(stderr,"msgget: msgget exitoso: msqid = %d\n", msqid);

/*
* We'll send message type 1
*/
sbuf.mtype = 1;
(void) strcpy(sbuf.mtext, "¿Conseguistes esto?");
buf_length = strlen(sbuf.mtext) + 1 ;
/*
* Enviando mensaje.
*/
if (msgsnd(msqid, &sbuf, buf_length, IPC_NOWAIT) < 0) {
printf ("%d, %d, %s, %d\n", msqid, sbuf.mtype, sbuf.mtext, buf_length);
perror("msgsnd");
exit(1);
}
else
printf("Message: \"%s\" Sent\n", sbuf.mtext);
exit(0);
}
$ gcc message_send.c -o message_send
Ejercicio 10
Crear el siguiente programa en c, que hace referencia a un programa que escribe, llamelo message_rec.c,
compílelo
#include <stdio.h>
#define MSGSZ 128


/*
* Declara la estructura del mensaje.
*/
typedef struct msgbuf {

long mtype;
char mtext[MSGSZ];
} message_buf;
main()
{
int msqid;
key_t key;
message_buf rbuf;
/*
* Consigue el id de la cola de mensje para el
* "name" 1234, el cual ha sido creado por
* el servidor.
*/
key = 1234;
if ((msqid = msgget(key, 0666)) < 0) {

perror("msgget");
exit(1);
}
/*
* Recibe una respuesta del mensaje de tipo 1.
*/
if (msgrcv(msqid, &rbuf, MSGSZ, 1, 0) < 0) {
perror("msgrcv");
exit(1);
}
/*
* Imprime la respuesta.
*/
printf("%s\n", rbuf.mtext);
exit(0);
}


$ gcc message_rec.c -o message_rec
III. EJERCICIOS PROPUESTOS

Ejercicio 1. Reescriba el programa del ejercicio resuelto 3 para que se pueda validar el ingreso de números
enteros
Ejercicio 2. Utilizando una tubería simple, redireccione la salida del ejercicio resuelto 2 aun archivo de texto
simple
Ejercicio 3. En el ejercicio resuelto 5 reacomode el tamaño del buffer para mensajes de cadenas de longitud de
8 caracteres
IV. CUESTIONARIO
1. ¿Qué hace la biblioteca sys/ipc.h en los ejercicios resueltos?
2. ¿Dónde se ubica la librería types.h en su distribución Ubuntu?
V. REFERENCIAS Y BIBLIOGRÁFIA RECOMENDADAS:

[1] Giordani Leonardo. 2013 07 21 Programación Concurrente - Colas de mensajes : online, Available:
http://www.linuxfocus.org/Castellano/March2003/article287.shtml
TÉCNICAS E INSTRUMENTOS DE EVALUACIÓN

TÉCNICAS: INSTRUMENTOS:
Ejercicios propuestos Rubricas
CRITERIOS DE EVALUACIÓN Y LOGROS ALCANZADOS

Criterio de 1 = Insatisfactorio 2 = En proceso 3 = Satisfactorio 4 = Sobresaliente
evaluación/
Niveles de
Expectativa
Informe El informe es difícil
El informe incluye la El informe incluyeEl informe está
de leer y no cuenta
mayor parte de la la informaciónclaramente detallado e
con la informacióninformación solicitada, solicitada y es incluye toda la
pedida (0) pero cuesta comprenderlo comprensible (4) información solicitada
(2) (8)
Cantidad de Uno o más de los Todos los temas han sido Todos los temas Todos los temas han
Información temas no han sido tratados y la mayor parte han sido tratados sido tratados y todas las
tratados (0) de las preguntas han sido y la mayor parte preguntas han sido

contestadas, como de las preguntas contestadas con tres o

mínimo, con una frase (2) han sido más frases cada una (6)
contestadas,
como mínimo con
dos frases cada
una (3)
Calidad de La información La información está La información La información está
información tiene poco que ver relacionada con el tema está claramente claramente relacionada
con el tema principal (2) relacionada con el con el tema principal y
principal (0) tema principal (3) presenta otros ejemplos
(6)
Calidad del No cumplió con El ejercicio fue Se llega a una Se llega a una solución
ejercicio realizar el ejercicio desarrollado pero no se solución utilizando del
planteado(0) llego a una solución o al utilizando el procedimiento sugerido
objetivo pedido(2) procedimiento en pocas líneas de
sugerido(3) código(4)

Guía de Laboratorio 5

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guía de Laboratorio 5

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD NACIONAL DE SAN AGUSTIN

FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

ASIGNATURA: Sistemas Operativos

COMPETENCIAS C.a Aplica de forma transformadora conocimientos de matemática, computación e

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Colas de Mensajes System V

/* message buffer for msgsnd and msgrcv calls */

El campo mtype representa el tipo de mensaje y es un número estrictamente positivo: la correspondencia

Antes de enfrentarnos a los argumentos estrictamente relacionados con la teoría de la concurrencia

int msgget(key_t key, int msgflg)

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

II. EJERCICIO RESUELTO

void enviarDatos(int msgid, long tipo){

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

int main(int argc, const char *argv[])

Para compilar este programa utilizamos el siguiente comando en línea de comandos

$ gcc -w crear.c -o crear

void leerDatos(int msgid,long tipo){

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

printf("tipo mensaje: [%ld] litros: [%d]\n",msm.mtype,msm.litros);

int main(int argc, const char *argv[])

Para compilar este programa utilizamos el siguiente comando en línea de comandos

$ gcc -w leer.c -o leer

// Programa en C para la cola de mensajes (proceso que escribe)

// Estructura para la cola de mensajes

// ftok genera la clave unica

// msgget crea una cola de mensajes

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

printf("Escribe datos : ");

// msgsnd envia mensajes

// display the message

Para compilar este programa utilizamos el siguiente comando en línea de comandos

$ gcc writer.c -o writer

// Programa en para la cola de mensajes (proceso lector)

// Estructura para la cola de mensajes

// ftok para generar la clave unica

// msgget para crear un cola de mensajes

// msgrcv para recibir el mensaje

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

msgrcv(msgid, &message, sizeof(message), 1, 0);

// muestre el mensajedisplay the message

// Para destruir la cola de mensajes

Para compilar este programa utilizamos el siguiente comando en línea de comandos

$ gcc reader.c -o reader

/* Nombre de archivo: msgq_send.c */

#define PERMS 0644

if ((key = ftok("msgq.txt", 'B')) == -1) {

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

if ((msqid = msgget(key, PERMS | IPC_CREAT)) == -1) {

while(fgets(buf.mtext, sizeof buf.mtext, stdin) != NULL) {

if (msgctl(msqid, IPC_RMID, NULL) == -1) {

Para compilar este programa utilizamos el siguiente comando en línea de comandos

$ gcc msgg_send.c -o msgg_send

/* Nombre de archivo: msgq_recv.c */

#define PERMS 0644

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

if ((key = ftok("msgq.txt", 'B')) == -1) {

if ((msqid = msgget(key, PERMS)) == -1) { /* conectando con la cola */

for(;;) { /* normalmente la recepción nunca termina pero tiene una conclusion */

Para compilar este programa utilizamos el siguiente comando en línea de comandos

$ gcc msgq_recv.c -o msgq_recv