Publiquen aqui el ejercicio de memoria compartida
+8
jhonatan
diliana moreno
Ricardo Bolivar
anabel masud
marian fernandez
juliana
orlando
Luis Hurtado
12 participantes
Página 1 de 1.
Publiquen aqui el ejercicio de memoria compartida
Publiquen como respuesta a este tema ejercicio de memoria compartida
Re: Publiquen aqui el ejercicio de memoria compartida
#include <sys/mmap.h>
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#define MAX_BUFFER 1024 / * tamaño del buffer */
#define DATOS_A_PRODUCIR 100000 /* datos a producir */
sem_t *huecos;
sem_t *elementos;
int buffer; /*puntero al buffer de números enteros */
void main(void){
int shd;
/*se crean e inician semáforos */
huecos = sem_open(”HUECOS”, OCREAT, 0700 MAX_BUFFER);
elementos = sem_open(”ELEMENTOS”, OCREAT, 0700, 0);
if (huecos = = -1 ││ elementos == -1) {
perror(”Error en sem_open”)
exit (1)
}
/* se crea el segmento de memoria compartida utilizado como
buffer circular */
shd = open(”BUFFER” O_CREATIOWRONLY, 0700);
if (shd = = -1)
perror ( “Error en open”);
exit (1)
}
ftruncate(shd, MAX_BUFFER*sizeof (int));
buffer = (int *)mmap(NULL, MAXBUFFER*sjzeof(int), PROT_WRITE,
MAP_SHARED, shd, 0);
if (buffer = = NULL)
perror (“Error en mmap”);
exit (1);
}
productor ( ) /* se ejecuta el código del productor */
/*se desproyecta el buffer */
munmuap(buffer, MAX_EUFFER*sizeof (int));
close(shd);
unlink(”BUFFER”);
/* cierran y se destruyen los semáforos */
sem_close (huecos);
sem_close (elementos);
sem_unlink(”HUECOS”;
sem_unlink(”ELEMENTOS”);
exit(0)
}
/* código del proceso productor */
void productor (void)
int dato; /* dato a producir */
int posicion = 0; /* posición donde insertar el elemento */
int j;
for (j = 0; j<DATOS_A_PRODUCIR; j++)
dato = j;
sem_wait (huecos); /* un hueco menos */
buffer[posición] =dato;
posición =(posición +l) % MAXBUFFER; /* nueva posición */
sem_post(elementos); /* un elemento más */;
}
return;
}
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#define MAX_BUFFER 1024 / * tamaño del buffer */
#define DATOS_A_PRODUCIR 100000 /* datos a producir */
sem_t *huecos;
sem_t *elementos;
int buffer; /*puntero al buffer de números enteros */
void main(void){
int shd;
/*se crean e inician semáforos */
huecos = sem_open(”HUECOS”, OCREAT, 0700 MAX_BUFFER);
elementos = sem_open(”ELEMENTOS”, OCREAT, 0700, 0);
if (huecos = = -1 ││ elementos == -1) {
perror(”Error en sem_open”)
exit (1)
}
/* se crea el segmento de memoria compartida utilizado como
buffer circular */
shd = open(”BUFFER” O_CREATIOWRONLY, 0700);
if (shd = = -1)
perror ( “Error en open”);
exit (1)
}
ftruncate(shd, MAX_BUFFER*sizeof (int));
buffer = (int *)mmap(NULL, MAXBUFFER*sjzeof(int), PROT_WRITE,
MAP_SHARED, shd, 0);
if (buffer = = NULL)
perror (“Error en mmap”);
exit (1);
}
productor ( ) /* se ejecuta el código del productor */
/*se desproyecta el buffer */
munmuap(buffer, MAX_EUFFER*sizeof (int));
close(shd);
unlink(”BUFFER”);
/* cierran y se destruyen los semáforos */
sem_close (huecos);
sem_close (elementos);
sem_unlink(”HUECOS”;
sem_unlink(”ELEMENTOS”);
exit(0)
}
/* código del proceso productor */
void productor (void)
int dato; /* dato a producir */
int posicion = 0; /* posición donde insertar el elemento */
int j;
for (j = 0; j<DATOS_A_PRODUCIR; j++)
dato = j;
sem_wait (huecos); /* un hueco menos */
buffer[posición] =dato;
posición =(posición +l) % MAXBUFFER; /* nueva posición */
sem_post(elementos); /* un elemento más */;
}
return;
}
orlando- Mensajes : 8
Puntos : 17
Reputación : 1
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
#include <stdio.h>
#include <sys/shm.h>
int main ()
{
FILE *archivocompartido;
key_t clavecompartida;
int mem = 0;
int contador = 0;
char *mcompartida = NULL;
archivocompartido = fopen
(”/tmp/acompartido”,”w+”);
clavecompartida = ftok
(”/tmp/acompartido”,33);
mem = shmget
(clavecompartida,sizeof(char *)*100,0777);
mcompartida = (char *)
shmat (mem,NULL,0);
printf (”Trabjando con el
segmento: %d\n”,mem);
printf (”Cada segundo se
actualiza el valor compartido, el programa dura un minuto\n”);
while (contador != 60)
{
contador = contador + 1;
sprintf (mcompartida,”%d”,contador);
sleep (1);
}
#include <sys/shm.h>
int main ()
{
FILE *archivocompartido;
key_t clavecompartida;
int mem = 0;
int contador = 0;
char *mcompartida = NULL;
archivocompartido = fopen
(”/tmp/acompartido”,”w+”);
clavecompartida = ftok
(”/tmp/acompartido”,33);
mem = shmget
(clavecompartida,sizeof(char *)*100,0777);
mcompartida = (char *)
shmat (mem,NULL,0);
printf (”Trabjando con el
segmento: %d\n”,mem);
printf (”Cada segundo se
actualiza el valor compartido, el programa dura un minuto\n”);
while (contador != 60)
{
contador = contador + 1;
sprintf (mcompartida,”%d”,contador);
sleep (1);
}
juliana- Mensajes : 2
Puntos : 4
Reputación : 0
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
Marian Fernandez
Naileh Fernandez
include
#include
int main ()
{
FILE *archivocompartido;
key_t clavecompartida;
int mem = 0;
char *mcompartida = NULL;
archivocompartido =
fopen
(”/tmp/acompartido”,”w+”);
clavecompartida = ftok
(”/tmp/acompartido”,33);
mem = shmget
(clavecompartida,sizeof(char *)*100,0777 | IPC_CREAT);
mcompartida = (char *) shmat
(mem,NULL,0);
printf (”Creando el
segmento
%d de memoria compartida\n\n”,mem);
printf (”Precione ENTER para
liberar los recursos compartidos\n”);
getchar ();
shmctl (mem,
IPC_RMID,
(struct shmid_ds *)NULL);
unlink (”/tmp/acompartido”);
return 0;
}
Modificar.c Este programa modifica la zona de memoria asignada
por asignar.c
#include
#include
int main ()
{
FILE *archivocompartido;
key_t clavecompartida;
int mem = 0;
int contador = 0;
char *mcompartida = NULL;
archivocompartido =
fopen
(”/tmp/acompartido”,”w+”);
clavecompartida = ftok
(”/tmp/acompartido”,33);
mem = shmget
(clavecompartida,sizeof(char *)*100,0777);
mcompartida = (char *)
shmat (mem,NULL,0);
printf (”Trabjando
con el
segmento: %d\n”,mem);
printf (”Cada segundo se
actualiza el valor compartido, el programa dura un minuto\n”);
while (contador !=
60)
{
contador = contador + 1;
sprintf (mcompartida,”%d”,contador);
sleep (1);
}
return 0;
Naileh Fernandez
include
#include
int main ()
{
FILE *archivocompartido;
key_t clavecompartida;
int mem = 0;
char *mcompartida = NULL;
archivocompartido =
fopen
(”/tmp/acompartido”,”w+”);
clavecompartida = ftok
(”/tmp/acompartido”,33);
mem = shmget
(clavecompartida,sizeof(char *)*100,0777 | IPC_CREAT);
mcompartida = (char *) shmat
(mem,NULL,0);
printf (”Creando el
segmento
%d de memoria compartida\n\n”,mem);
printf (”Precione ENTER para
liberar los recursos compartidos\n”);
getchar ();
shmctl (mem,
IPC_RMID,
(struct shmid_ds *)NULL);
unlink (”/tmp/acompartido”);
return 0;
}
Modificar.c Este programa modifica la zona de memoria asignada
por asignar.c
#include
#include
int main ()
{
FILE *archivocompartido;
key_t clavecompartida;
int mem = 0;
int contador = 0;
char *mcompartida = NULL;
archivocompartido =
fopen
(”/tmp/acompartido”,”w+”);
clavecompartida = ftok
(”/tmp/acompartido”,33);
mem = shmget
(clavecompartida,sizeof(char *)*100,0777);
mcompartida = (char *)
shmat (mem,NULL,0);
printf (”Trabjando
con el
segmento: %d\n”,mem);
printf (”Cada segundo se
actualiza el valor compartido, el programa dura un minuto\n”);
while (contador !=
60)
{
contador = contador + 1;
sprintf (mcompartida,”%d”,contador);
sleep (1);
}
return 0;
marian fernandez- Mensajes : 4
Puntos : 6
Reputación : 0
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
#include <stdio.h>
#include <sys/shm.h>
int main ()
{
FILE *archivocompartido;
key_t clavecompartida;
int mem = 0;
int contador = 0;
char *mcompartida = NULL;
archivocompartido = fopen
(”/tmp/acompartido”,”w+”);
clavecompartida = ftok
(”/tmp/acompartido”,33);
mem = shmget
(clavecompartida,sizeof(char *)*100,0777);
mcompartida = (char *)
shmat (mem,NULL,0);
printf (”Trabjando con el
segmento: %d\n”,mem);
printf (”Cada segundo se
actualiza el valor compartido, el programa dura un minuto\n”);
while (contador != 60)
{
contador = contador + 1;
sprintf (mcompartida,”%d”,contador);
sleep (1);
}
anabel masud
#include <sys/shm.h>
int main ()
{
FILE *archivocompartido;
key_t clavecompartida;
int mem = 0;
int contador = 0;
char *mcompartida = NULL;
archivocompartido = fopen
(”/tmp/acompartido”,”w+”);
clavecompartida = ftok
(”/tmp/acompartido”,33);
mem = shmget
(clavecompartida,sizeof(char *)*100,0777);
mcompartida = (char *)
shmat (mem,NULL,0);
printf (”Trabjando con el
segmento: %d\n”,mem);
printf (”Cada segundo se
actualiza el valor compartido, el programa dura un minuto\n”);
while (contador != 60)
{
contador = contador + 1;
sprintf (mcompartida,”%d”,contador);
sleep (1);
}
anabel masud
anabel masud- Mensajes : 6
Puntos : 14
Reputación : 0
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
Bolivar Ricardo
Bracho Jose
#include <sys/mmap.h>
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#define MAX_BUFFER 1024 / * tamaño del buffer */
#define DATOS_A_PRODUCIR 100000 /* datos a producir */
sem_t *huecos;
sem_t *elementos;
int buffer; /*puntero al buffer de números enteros */
void main(void){
int shd;
/*se crean e inician semáforos */
huecos = sem_open(”HUECOS”, OCREAT, 0700 MAX_BUFFER);
elementos = sem_open(”ELEMENTOS”, OCREAT, 0700, 0);
if (huecos = = -1 ││ elementos == -1) {
perror(”Error en sem_open”)
exit (1)
}
/* se crea el segmento de memoria compartida utilizado como
buffer circular */
shd = open(”BUFFER” O_CREATIOWRONLY, 0700);
if (shd = = -1)
perror ( “Error en open”);
exit (1)
}
ftruncate(shd, MAX_BUFFER*sizeof (int));
buffer = (int *)mmap(NULL, MAXBUFFER*sjzeof(int), PROT_WRITE,
MAP_SHARED, shd, 0);
if (buffer = = NULL)
perror (“Error en mmap”);
exit (1);
}
productor ( ) /* se ejecuta el código del productor */
/*se desproyecta el buffer */
munmuap(buffer, MAX_EUFFER*sizeof (int));
close(shd);
unlink(”BUFFER”);
/* cierran y se destruyen los semáforos */
sem_close (huecos);
sem_close (elementos);
sem_unlink(”HUECOS”;
sem_unlink(”ELEMENTOS”);
exit(0)
}
/* código del proceso productor */
void productor (void)
int dato; /* dato a producir */
int posicion = 0; /* posición donde insertar el elemento */
int j;
for (j = 0; j<DATOS_A_PRODUCIR; j++)
dato = j;
sem_wait (huecos); /* un hueco menos */
buffer[posición] =dato;
posición =(posición +l) % MAXBUFFER; /* nueva posición */
sem_post(elementos); /* un elemento más */;
}
return;
}
Bracho Jose
#include <sys/mmap.h>
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#define MAX_BUFFER 1024 / * tamaño del buffer */
#define DATOS_A_PRODUCIR 100000 /* datos a producir */
sem_t *huecos;
sem_t *elementos;
int buffer; /*puntero al buffer de números enteros */
void main(void){
int shd;
/*se crean e inician semáforos */
huecos = sem_open(”HUECOS”, OCREAT, 0700 MAX_BUFFER);
elementos = sem_open(”ELEMENTOS”, OCREAT, 0700, 0);
if (huecos = = -1 ││ elementos == -1) {
perror(”Error en sem_open”)
exit (1)
}
/* se crea el segmento de memoria compartida utilizado como
buffer circular */
shd = open(”BUFFER” O_CREATIOWRONLY, 0700);
if (shd = = -1)
perror ( “Error en open”);
exit (1)
}
ftruncate(shd, MAX_BUFFER*sizeof (int));
buffer = (int *)mmap(NULL, MAXBUFFER*sjzeof(int), PROT_WRITE,
MAP_SHARED, shd, 0);
if (buffer = = NULL)
perror (“Error en mmap”);
exit (1);
}
productor ( ) /* se ejecuta el código del productor */
/*se desproyecta el buffer */
munmuap(buffer, MAX_EUFFER*sizeof (int));
close(shd);
unlink(”BUFFER”);
/* cierran y se destruyen los semáforos */
sem_close (huecos);
sem_close (elementos);
sem_unlink(”HUECOS”;
sem_unlink(”ELEMENTOS”);
exit(0)
}
/* código del proceso productor */
void productor (void)
int dato; /* dato a producir */
int posicion = 0; /* posición donde insertar el elemento */
int j;
for (j = 0; j<DATOS_A_PRODUCIR; j++)
dato = j;
sem_wait (huecos); /* un hueco menos */
buffer[posición] =dato;
posición =(posición +l) % MAXBUFFER; /* nueva posición */
sem_post(elementos); /* un elemento más */;
}
return;
}
Ricardo Bolivar- Mensajes : 3
Puntos : 5
Reputación : 0
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
corintia gutierrez
diliana moreno
gomez rosangela
#include <stdio.h>
#include <time.h>
//funcion
int cambiarColor( int );
main( )
{
int tiempoSimulacion, tiempo;
int semaforo1 = 0, semaforo2 = 1;
bool entraPrimerVez = true;
time_t comienzo, actual;
//Se introduce el tiempo durante el cual se va a ejecutar la simulacion
//Y tambien el tiempo en el que queremos que cambie el color del semaforo
printf( "Introduzca el tiempo en segundos en el que se va a realizar la simulacionn" );
scanf( "%d", &tiempoSimulacion );
printf( "Introduzca el tiempo en segundos del cambio del color de los semaforosn" );
scanf( "%d", &tiempo );
comienzo = time( NULL );
do
{
actual = time( NULL );
//Entra al cuerpo del if cada que haya transcurrido el tiempo de cambio ingresadopor el usuario
if( int( difftime(actual, comienzo) ) % tiempo == 0 && entraPrimerVez )
{
entraPrimerVez = false;
semaforo1 = cambiarColor( semaforo1 );
semaforo2 = cambiarColor( semaforo2 );
if( semaforo1 == 1 )
{
printf( "El semaforo 1 esta en Verde y el semaforo 2 en Rojonn" );
}
else
{
printf( "El semaforo 1 esta en Rojo y el semaforo 2 en Verdenn" );
}
}
if( int( difftime(actual, comienzo) ) % tiempo > 0 )
{
entraPrimerVez = true;
}
}
while( int( difftime(actual, comienzo) ) < tiempoSimulacion );
return 0;
}
int cambiarColor( int semaforo )
{
//Si el valor del semaforo_1 es 1 es porque este semaforo este en verde, lo que indica que este pasa a rojo
//y el semaforo_2 pasaria a verde, de lo contrario se invertiria el color segun lo explicado anteriormente
if( semaforo == 1 )
{
semaforo = 0;
}
else
{
semaforo = 1;
}
return semaforo;
}
diliana moreno
gomez rosangela
#include <stdio.h>
#include <time.h>
//funcion
int cambiarColor( int );
main( )
{
int tiempoSimulacion, tiempo;
int semaforo1 = 0, semaforo2 = 1;
bool entraPrimerVez = true;
time_t comienzo, actual;
//Se introduce el tiempo durante el cual se va a ejecutar la simulacion
//Y tambien el tiempo en el que queremos que cambie el color del semaforo
printf( "Introduzca el tiempo en segundos en el que se va a realizar la simulacionn" );
scanf( "%d", &tiempoSimulacion );
printf( "Introduzca el tiempo en segundos del cambio del color de los semaforosn" );
scanf( "%d", &tiempo );
comienzo = time( NULL );
do
{
actual = time( NULL );
//Entra al cuerpo del if cada que haya transcurrido el tiempo de cambio ingresadopor el usuario
if( int( difftime(actual, comienzo) ) % tiempo == 0 && entraPrimerVez )
{
entraPrimerVez = false;
semaforo1 = cambiarColor( semaforo1 );
semaforo2 = cambiarColor( semaforo2 );
if( semaforo1 == 1 )
{
printf( "El semaforo 1 esta en Verde y el semaforo 2 en Rojonn" );
}
else
{
printf( "El semaforo 1 esta en Rojo y el semaforo 2 en Verdenn" );
}
}
if( int( difftime(actual, comienzo) ) % tiempo > 0 )
{
entraPrimerVez = true;
}
}
while( int( difftime(actual, comienzo) ) < tiempoSimulacion );
return 0;
}
int cambiarColor( int semaforo )
{
//Si el valor del semaforo_1 es 1 es porque este semaforo este en verde, lo que indica que este pasa a rojo
//y el semaforo_2 pasaria a verde, de lo contrario se invertiria el color segun lo explicado anteriormente
if( semaforo == 1 )
{
semaforo = 0;
}
else
{
semaforo = 1;
}
return semaforo;
}
diliana moreno- Mensajes : 4
Puntos : 6
Reputación : 0
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
#include
#include
#define PERMISOS 0644
/* crea_sem: abre o crea un semáforo */
int crea_sem ( key_t clave, int valor_inicial )
{
int semid = semget( /* Abre o crea un semáforo... */
clave, /* con una cierta clave */
1, /* con un solo elemento */
IPC_CREAT|PERMISOS /* lo crea (IPC_CREAT) con
unos PERMISOS */
);
if ( semid==-1 ) return -1;
/* Da el valor inicial al semáforo */
semctl ( semid, 0, SETVAL, valor_inicial );
return semid;
}
/* abre_sem: Abrir un semáforo que otro proceso ya creó */
int abre_sem (key_t clave)
{
return semget(clave,1,0);
}
/* Operaciones P y V */
void sem_P ( int semid ) /* Operación P */
{
struct sembuf op_P [] =
{
0, -1, 0 /* Decrementa semval o bloquea si cero */
};
semop ( semid, op_P, 1 );
}
void sem_V ( int semid ) /* Operación V */
{
struct sembuf op_V [] =
{
0, 1, 0 /* Incrementa en 1 el semáforo */
};
semop ( semid, op_V, 1 );
}
#include
#define PERMISOS 0644
/* crea_sem: abre o crea un semáforo */
int crea_sem ( key_t clave, int valor_inicial )
{
int semid = semget( /* Abre o crea un semáforo... */
clave, /* con una cierta clave */
1, /* con un solo elemento */
IPC_CREAT|PERMISOS /* lo crea (IPC_CREAT) con
unos PERMISOS */
);
if ( semid==-1 ) return -1;
/* Da el valor inicial al semáforo */
semctl ( semid, 0, SETVAL, valor_inicial );
return semid;
}
/* abre_sem: Abrir un semáforo que otro proceso ya creó */
int abre_sem (key_t clave)
{
return semget(clave,1,0);
}
/* Operaciones P y V */
void sem_P ( int semid ) /* Operación P */
{
struct sembuf op_P [] =
{
0, -1, 0 /* Decrementa semval o bloquea si cero */
};
semop ( semid, op_P, 1 );
}
void sem_V ( int semid ) /* Operación V */
{
struct sembuf op_V [] =
{
0, 1, 0 /* Incrementa en 1 el semáforo */
};
semop ( semid, op_V, 1 );
}
jhonatan- Mensajes : 7
Puntos : 15
Reputación : 0
Fecha de inscripción : 05/05/2010
Edad : 33
Re: Publiquen aqui el ejercicio de memoria compartida
Jose Rodriguez Josè Saavedra
#include <stdio.h>
#include <time.h>
//funcion
int cambiarColor( int );
main( )
{
int tiempoSimulacion, tiempo;
int semaforo1 = 0, semaforo2 = 1;
bool entraPrimerVez = true;
time_t comienzo, actual;
//Se introduce el tiempo durante el cual se va a ejecutar la simulacion
//Y tambien el tiempo en el que queremos que cambie el color del semaforo
printf( "Introduzca el tiempo en segundos en el que se va a realizar la simulacionn" );
scanf( "%d", &tiempoSimulacion );
printf( "Introduzca el tiempo en segundos del cambio del color de los semaforosn" );
scanf( "%d", &tiempo );
comienzo = time( NULL );
do
{
actual = time( NULL );
//Entra al cuerpo del if cada que haya transcurrido el tiempo de cambio ingresadopor el usuario
if( int( difftime(actual, comienzo) ) % tiempo == 0 && entraPrimerVez )
{
entraPrimerVez = false;
semaforo1 = cambiarColor( semaforo1 );
semaforo2 = cambiarColor( semaforo2 );
if( semaforo1 == 1 )
{
printf( "El semaforo 1 esta en Verde y el semaforo 2 en Rojonn" );
}
else
{
printf( "El semaforo 1 esta en Rojo y el semaforo 2 en Verdenn" );
}
}
if( int( difftime(actual, comienzo) ) % tiempo > 0 )
{
entraPrimerVez = true;
}
}
while( int( difftime(actual, comienzo) ) < tiempoSimulacion );
return 0;
}
int cambiarColor( int semaforo )
{
//Si el valor del semaforo_1 es 1 es porque este semaforo este en verde, lo que indica que este pasa a rojo
//y el semaforo_2 pasaria a verde, de lo contrario se invertiria el color segun lo explicado anteriormente
if( semaforo == 1 )
{
semaforo = 0;
}
else
{
semaforo = 1;
}
return semaforo;
}
#include <stdio.h>
#include <time.h>
//funcion
int cambiarColor( int );
main( )
{
int tiempoSimulacion, tiempo;
int semaforo1 = 0, semaforo2 = 1;
bool entraPrimerVez = true;
time_t comienzo, actual;
//Se introduce el tiempo durante el cual se va a ejecutar la simulacion
//Y tambien el tiempo en el que queremos que cambie el color del semaforo
printf( "Introduzca el tiempo en segundos en el que se va a realizar la simulacionn" );
scanf( "%d", &tiempoSimulacion );
printf( "Introduzca el tiempo en segundos del cambio del color de los semaforosn" );
scanf( "%d", &tiempo );
comienzo = time( NULL );
do
{
actual = time( NULL );
//Entra al cuerpo del if cada que haya transcurrido el tiempo de cambio ingresadopor el usuario
if( int( difftime(actual, comienzo) ) % tiempo == 0 && entraPrimerVez )
{
entraPrimerVez = false;
semaforo1 = cambiarColor( semaforo1 );
semaforo2 = cambiarColor( semaforo2 );
if( semaforo1 == 1 )
{
printf( "El semaforo 1 esta en Verde y el semaforo 2 en Rojonn" );
}
else
{
printf( "El semaforo 1 esta en Rojo y el semaforo 2 en Verdenn" );
}
}
if( int( difftime(actual, comienzo) ) % tiempo > 0 )
{
entraPrimerVez = true;
}
}
while( int( difftime(actual, comienzo) ) < tiempoSimulacion );
return 0;
}
int cambiarColor( int semaforo )
{
//Si el valor del semaforo_1 es 1 es porque este semaforo este en verde, lo que indica que este pasa a rojo
//y el semaforo_2 pasaria a verde, de lo contrario se invertiria el color segun lo explicado anteriormente
if( semaforo == 1 )
{
semaforo = 0;
}
else
{
semaforo = 1;
}
return semaforo;
}
Jose Saavedra- Mensajes : 5
Puntos : 8
Reputación : 1
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
este programa sirve para simular un semaforo de dos carriles
#include
#include
//funcion
int cambiarColor( int );
main( )
{
int tiempoSimulacion, tiempo;
int semaforo1 = 0, semaforo2 = 1;
bool entraPrimerVez = true;
time_t comienzo, actual;
//Se introduce el tiempo durante el cual se va a ejecutar la simulacion
//Y tambien el tiempo en el que queremos que cambie el color del semaforo
printf( "Introduzca el tiempo en segundos en el que se va a realizar la simulacionn" );
scanf( "%d", &tiempoSimulacion );
printf( "Introduzca el tiempo en segundos del cambio del color de los semaforosn" );
scanf( "%d", &tiempo );
comienzo = time( NULL );
do
{
actual = time( NULL );
//Entra al cuerpo del if cada que haya transcurrido el tiempo de cambio ingresadopor el usuario
if( int( difftime(actual, comienzo) ) % tiempo == 0 && entraPrimerVez )
{
entraPrimerVez = false;
semaforo1 = cambiarColor( semaforo1 );
semaforo2 = cambiarColor( semaforo2 );
if( semaforo1 == 1 )
{
printf( "El semaforo 1 esta en Verde y el semaforo 2 en Rojonn" );
}
else
{
printf( "El semaforo 1 esta en Rojo y el semaforo 2 en Verdenn" );
}
}
if( int( difftime(actual, comienzo) ) % tiempo > 0 )
{
entraPrimerVez = true;
}
}
while( int( difftime(actual, comienzo) ) < tiempoSimulacion );
return 0;
}
int cambiarColor( int semaforo )
{
//Si el valor del semaforo_1 es 1 es porque este semaforo este en verde, lo que indica que este pasa a rojo
//y el semaforo_2 pasaria a verde, de lo contrario se invertiria el color segun lo explicado anteriormente
if( semaforo == 1 )
{
semaforo = 0;
}
else
{
semaforo = 1;
}
return semaforo;
}
#include
#include
//funcion
int cambiarColor( int );
main( )
{
int tiempoSimulacion, tiempo;
int semaforo1 = 0, semaforo2 = 1;
bool entraPrimerVez = true;
time_t comienzo, actual;
//Se introduce el tiempo durante el cual se va a ejecutar la simulacion
//Y tambien el tiempo en el que queremos que cambie el color del semaforo
printf( "Introduzca el tiempo en segundos en el que se va a realizar la simulacionn" );
scanf( "%d", &tiempoSimulacion );
printf( "Introduzca el tiempo en segundos del cambio del color de los semaforosn" );
scanf( "%d", &tiempo );
comienzo = time( NULL );
do
{
actual = time( NULL );
//Entra al cuerpo del if cada que haya transcurrido el tiempo de cambio ingresadopor el usuario
if( int( difftime(actual, comienzo) ) % tiempo == 0 && entraPrimerVez )
{
entraPrimerVez = false;
semaforo1 = cambiarColor( semaforo1 );
semaforo2 = cambiarColor( semaforo2 );
if( semaforo1 == 1 )
{
printf( "El semaforo 1 esta en Verde y el semaforo 2 en Rojonn" );
}
else
{
printf( "El semaforo 1 esta en Rojo y el semaforo 2 en Verdenn" );
}
}
if( int( difftime(actual, comienzo) ) % tiempo > 0 )
{
entraPrimerVez = true;
}
}
while( int( difftime(actual, comienzo) ) < tiempoSimulacion );
return 0;
}
int cambiarColor( int semaforo )
{
//Si el valor del semaforo_1 es 1 es porque este semaforo este en verde, lo que indica que este pasa a rojo
//y el semaforo_2 pasaria a verde, de lo contrario se invertiria el color segun lo explicado anteriormente
if( semaforo == 1 )
{
semaforo = 0;
}
else
{
semaforo = 1;
}
return semaforo;
}
jose luis- Mensajes : 3
Puntos : 7
Reputación : 0
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
#include
#include
#include
#include
#include
#include
#define TAM_SEG 100
int main (int argc, char **argv)
{
key_t clave;
int shmid;
char *seg;
clave=ftok ( " . ", ´S´);
if ( ( shmid=shmget (clave, TAM_SEG,IPC_CREAT|IPC_EXCL|0660) ) ==-1 )
{
printf("el segmento de memoria compartida ya existe\n");
printf(" abriendo como cliente\n");
if ( ( shmid=shmget (clave, TAM_SEG,0) ) ==-1)
printf("error al abrir el segmento\n");
}
else
printf("Nuevo segmento creado\n");
if (argc==1)
printf(" error de argumentos\n");
else if (shmid != -1)
{
if ( (seg=shmat (shmid, NULL,0 ) ) == (char *) -1)
printf("error al mapear el segmento\n");
else
switch ( tolower (argv[1] [0] ) )
{
case ´e´ : /* escribir en el segmento */
if (argc==3)
{
strncpi (seg,argv [2], TAM_SEG-1);
if (strlen (argv [2] ) >=TAM_SEG-1)
seg [TAM_SEG-1]=´\0´;
printf("hecho...\n");
}
break;
case ´1´:/* leer del segmento */
printf (" el contenido del segmento es: %s\n", seg);
break;
case ´b´:
shmctl ( shmid, IPC_RMID,0);
printf("Segmento de memoria marcado para borrar\n");
break;
default:
break;
}
shmdt (seg);
}
return(0);
alumnos: gomez erika, belisario emmanuel, marabay maria. ads 03-01
#include
#include
#include
#include
#include
#define TAM_SEG 100
int main (int argc, char **argv)
{
key_t clave;
int shmid;
char *seg;
clave=ftok ( " . ", ´S´);
if ( ( shmid=shmget (clave, TAM_SEG,IPC_CREAT|IPC_EXCL|0660) ) ==-1 )
{
printf("el segmento de memoria compartida ya existe\n");
printf(" abriendo como cliente\n");
if ( ( shmid=shmget (clave, TAM_SEG,0) ) ==-1)
printf("error al abrir el segmento\n");
}
else
printf("Nuevo segmento creado\n");
if (argc==1)
printf(" error de argumentos\n");
else if (shmid != -1)
{
if ( (seg=shmat (shmid, NULL,0 ) ) == (char *) -1)
printf("error al mapear el segmento\n");
else
switch ( tolower (argv[1] [0] ) )
{
case ´e´ : /* escribir en el segmento */
if (argc==3)
{
strncpi (seg,argv [2], TAM_SEG-1);
if (strlen (argv [2] ) >=TAM_SEG-1)
seg [TAM_SEG-1]=´\0´;
printf("hecho...\n");
}
break;
case ´1´:/* leer del segmento */
printf (" el contenido del segmento es: %s\n", seg);
break;
case ´b´:
shmctl ( shmid, IPC_RMID,0);
printf("Segmento de memoria marcado para borrar\n");
break;
default:
break;
}
shmdt (seg);
}
return(0);
alumnos: gomez erika, belisario emmanuel, marabay maria. ads 03-01
erika gomez- Mensajes : 7
Puntos : 7
Reputación : 0
Fecha de inscripción : 11/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
#include <sys/mmap.h>
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#define MAX_BUFFER 1024 / * tamaño del buffer */
#define DATOS_A_PRODUCIR 100000 /* datos a producir */
sem_t *huecos;
sem_t *elementos;
int buffer; /*puntero al buffer de números enteros */
void main(void){
int shd;
/*se crean e inician semáforos */
huecos = sem_open(”HUECOS”, OCREAT, 0700 MAX_BUFFER);
elementos = sem_open(”ELEMENTOS”, OCREAT, 0700, 0);
if (huecos = = -1 ││ elementos == -1) {
perror(”Error en sem_open”)
exit (1)
}
/* se crea el segmento de memoria compartida utilizado como
buffer circular */
shd = open(”BUFFER” O_CREATIOWRONLY, 0700);
if (shd = = -1)
perror ( “Error en open”);
exit (1)
}
ftruncate(shd, MAX_BUFFER*sizeof (int));
buffer = (int *)mmap(NULL, MAXBUFFER*sjzeof(int), PROT_WRITE,
MAP_SHARED, shd, 0);
if (buffer = = NULL)
perror (“Error en mmap”);
exit (1);
}
productor ( ) /* se ejecuta el código del productor */
/*se desproyecta el buffer */
munmuap(buffer, MAX_EUFFER*sizeof (int));
close(shd);
unlink(”BUFFER”);
/* cierran y se destruyen los semáforos */
sem_close (huecos);
sem_close (elementos);
sem_unlink(”HUECOS”;
sem_unlink(”ELEMENTOS”);
exit(0)
}
/* código del proceso productor */
void productor (void)
int dato; /* dato a producir */
int posicion = 0; /* posición donde insertar el elemento */
int j;
for (j = 0; j<DATOS_A_PRODUCIR; j++)
dato = j;
sem_wait (huecos); /* un hueco menos */
buffer[posición] =dato;
posición =(posición +l) % MAXBUFFER; /* nueva posición */
sem_post(elementos); /* un elemento más */;
}
return;
}
Jose Rodriguez y Jose Saavedra
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#define MAX_BUFFER 1024 / * tamaño del buffer */
#define DATOS_A_PRODUCIR 100000 /* datos a producir */
sem_t *huecos;
sem_t *elementos;
int buffer; /*puntero al buffer de números enteros */
void main(void){
int shd;
/*se crean e inician semáforos */
huecos = sem_open(”HUECOS”, OCREAT, 0700 MAX_BUFFER);
elementos = sem_open(”ELEMENTOS”, OCREAT, 0700, 0);
if (huecos = = -1 ││ elementos == -1) {
perror(”Error en sem_open”)
exit (1)
}
/* se crea el segmento de memoria compartida utilizado como
buffer circular */
shd = open(”BUFFER” O_CREATIOWRONLY, 0700);
if (shd = = -1)
perror ( “Error en open”);
exit (1)
}
ftruncate(shd, MAX_BUFFER*sizeof (int));
buffer = (int *)mmap(NULL, MAXBUFFER*sjzeof(int), PROT_WRITE,
MAP_SHARED, shd, 0);
if (buffer = = NULL)
perror (“Error en mmap”);
exit (1);
}
productor ( ) /* se ejecuta el código del productor */
/*se desproyecta el buffer */
munmuap(buffer, MAX_EUFFER*sizeof (int));
close(shd);
unlink(”BUFFER”);
/* cierran y se destruyen los semáforos */
sem_close (huecos);
sem_close (elementos);
sem_unlink(”HUECOS”;
sem_unlink(”ELEMENTOS”);
exit(0)
}
/* código del proceso productor */
void productor (void)
int dato; /* dato a producir */
int posicion = 0; /* posición donde insertar el elemento */
int j;
for (j = 0; j<DATOS_A_PRODUCIR; j++)
dato = j;
sem_wait (huecos); /* un hueco menos */
buffer[posición] =dato;
posición =(posición +l) % MAXBUFFER; /* nueva posición */
sem_post(elementos); /* un elemento más */;
}
return;
}
Jose Rodriguez y Jose Saavedra
Jose Saavedra- Mensajes : 5
Puntos : 8
Reputación : 1
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
profesor disculpem nosotros le mandamos el ejercicio de memoria compartida y por que no aparec publicado
Anny Fernandez- Mensajes : 9
Puntos : 11
Reputación : 0
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
Es probable que lo hayan publicado en otra parte del foro
Re: Publiquen aqui el ejercicio de memoria compartida
entonce que quiere decir con eso que perdimos la nota xq yo estoy segura que nosotro le mandamos ese ejercicio como recuperamos esa nota ahora.
Anny Fernandez- Mensajes : 9
Puntos : 11
Reputación : 0
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
Si lo publicaron en otra parte, no hay problema, yo igual lo corro, pero sino lo publicaron entonces, el martes hablamos en clase.
Re: Publiquen aqui el ejercicio de memoria compartida
lector( ) {
wait(sem_lectores);
int_lectores= n_lectores + 1;
if(n_lectores= =1)
wait(sem_recurso);
signal(sem-lectores);
< consultar el recurso compartido>
wait(sem_lectores);
n_lectores= n_lectores_1;
if(n-lectores= =0)
signal(sem_recurso);
signal(sem-lectores);
}
Escritor () {
wait(sem_recurso);
/*se puede modificar el recurso */
signal(sem_recurso);
}
#include <sys/shm.h>
#include <iostream.h>
#include <unistd.h>
void main()
{
key_t Clave;
int Id_Memoria;
int *Memoria = NULL;
int i,j;
//
// Conseguimos una clave para la memoria compartida. Todos los
// procesos que quieran compartir la memoria, deben obtener la misma
// clave. Esta se puede conseguir por medio de la función ftok.
// A esta función se le pasa un fichero cualquiera que exista y esté
// accesible (todos los procesos deben pasar el mismo fichero) y un
// entero cualquiera (todos los procesos el mismo entero).
//
Clave = ftok ("/bin/ls", 33);
if (Clave == -1)
{
cout << "No consigo clave para memoria compartida" << endl;
exit(0);
}
//
// Creamos la memoria con la clave recién conseguida. Para ello llamamos
// a la función shmget pasándole la clave, el tamaño de memoria que
// queremos reservar (100 enteros en nuestro caso) y unos flags.
// Los flags son los permisos de lectura/escritura/ejecucion
// para propietario, grupo y otros (es el 777 en octal) y el
// flag IPC_CREAT para indicar que cree la memoria.
// La función nos devuelve un identificador para la memoria recién
// creada.
//
Id_Memoria = shmget (Clave, sizeof(int)*100, 0777 | IPC_CREAT);
if (Id_Memoria == -1)
{
cout << "No consigo Id para memoria compartida" << endl;
exit (0);
}
//
// Una vez creada la memoria, hacemos que uno de nuestros punteros
// apunte a la zona de memoria recién creada. Para ello llamamos a
// shmat, pasándole el identificador obtenido anteriormente y un
// par de parámetros extraños, que con ceros vale.
//
Memoria = (int *)shmat (Id_Memoria, (char *)0, 0);
if (Memoria == NULL)
{
cout << "No consigo memoria compartida" << endl;
exit (0);
}
//
// Ya podemos utilizar la memoria.
// Escribimos cosas en la memoria. Los números de 1 a 10 esperando
// un segundo entre ellos. Estos datos serán los que lea el otro
// proceso.
//
for (i=0; i<10; i++)
{
for (j=0; j<100; j++)
{
Memoria[j] = i;
}
cout << "Escrito " << i << endl;
sleep (1);
}
//
// Terminada de usar la memoria compartida, la liberamos.
//
shmdt ((char *)Memoria);
shmctl (Id_Memoria, IPC_RMID, (struct shmid_ds *)NULL);
}
wait(sem_lectores);
int_lectores= n_lectores + 1;
if(n_lectores= =1)
wait(sem_recurso);
signal(sem-lectores);
< consultar el recurso compartido>
wait(sem_lectores);
n_lectores= n_lectores_1;
if(n-lectores= =0)
signal(sem_recurso);
signal(sem-lectores);
}
Escritor () {
wait(sem_recurso);
/*se puede modificar el recurso */
signal(sem_recurso);
}
#include <sys/shm.h>
#include <iostream.h>
#include <unistd.h>
void main()
{
key_t Clave;
int Id_Memoria;
int *Memoria = NULL;
int i,j;
//
// Conseguimos una clave para la memoria compartida. Todos los
// procesos que quieran compartir la memoria, deben obtener la misma
// clave. Esta se puede conseguir por medio de la función ftok.
// A esta función se le pasa un fichero cualquiera que exista y esté
// accesible (todos los procesos deben pasar el mismo fichero) y un
// entero cualquiera (todos los procesos el mismo entero).
//
Clave = ftok ("/bin/ls", 33);
if (Clave == -1)
{
cout << "No consigo clave para memoria compartida" << endl;
exit(0);
}
//
// Creamos la memoria con la clave recién conseguida. Para ello llamamos
// a la función shmget pasándole la clave, el tamaño de memoria que
// queremos reservar (100 enteros en nuestro caso) y unos flags.
// Los flags son los permisos de lectura/escritura/ejecucion
// para propietario, grupo y otros (es el 777 en octal) y el
// flag IPC_CREAT para indicar que cree la memoria.
// La función nos devuelve un identificador para la memoria recién
// creada.
//
Id_Memoria = shmget (Clave, sizeof(int)*100, 0777 | IPC_CREAT);
if (Id_Memoria == -1)
{
cout << "No consigo Id para memoria compartida" << endl;
exit (0);
}
//
// Una vez creada la memoria, hacemos que uno de nuestros punteros
// apunte a la zona de memoria recién creada. Para ello llamamos a
// shmat, pasándole el identificador obtenido anteriormente y un
// par de parámetros extraños, que con ceros vale.
//
Memoria = (int *)shmat (Id_Memoria, (char *)0, 0);
if (Memoria == NULL)
{
cout << "No consigo memoria compartida" << endl;
exit (0);
}
//
// Ya podemos utilizar la memoria.
// Escribimos cosas en la memoria. Los números de 1 a 10 esperando
// un segundo entre ellos. Estos datos serán los que lea el otro
// proceso.
//
for (i=0; i<10; i++)
{
for (j=0; j<100; j++)
{
Memoria[j] = i;
}
cout << "Escrito " << i << endl;
sleep (1);
}
//
// Terminada de usar la memoria compartida, la liberamos.
//
shmdt ((char *)Memoria);
shmctl (Id_Memoria, IPC_RMID, (struct shmid_ds *)NULL);
}
Anny Fernandez- Mensajes : 9
Puntos : 11
Reputación : 0
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
lector( ) {
wait(sem_lectores);
int_lectores= n_lectores + 1;
if(n_lectores= =1)
wait(sem_recurso);
signal(sem-lectores);
< consultar el recurso compartido>
wait(sem_lectores);
n_lectores= n_lectores_1;
if(n-lectores= =0)
signal(sem_recurso);
signal(sem-lectores);
}
Escritor () {
wait(sem_recurso);
/*se puede modificar el recurso */
signal(sem_recurso);
}
#include <sys/shm.h>
#include <iostream.h>
#include <unistd.h>
void main()
{
key_t Clave;
int Id_Memoria;
int *Memoria = NULL;
int i,j;
//
// Conseguimos una clave para la memoria compartida. Todos los
// procesos que quieran compartir la memoria, deben obtener la misma
// clave. Esta se puede conseguir por medio de la función ftok.
// A esta función se le pasa un fichero cualquiera que exista y esté
// accesible (todos los procesos deben pasar el mismo fichero) y un
// entero cualquiera (todos los procesos el mismo entero).
//
Clave = ftok ("/bin/ls", 33);
if (Clave == -1)
{
cout << "No consigo clave para memoria compartida" << endl;
exit(0);
}
//
// Creamos la memoria con la clave recién conseguida. Para ello llamamos
// a la función shmget pasándole la clave, el tamaño de memoria que
// queremos reservar (100 enteros en nuestro caso) y unos flags.
// Los flags son los permisos de lectura/escritura/ejecucion
// para propietario, grupo y otros (es el 777 en octal) y el
// flag IPC_CREAT para indicar que cree la memoria.
// La función nos devuelve un identificador para la memoria recién
// creada.
//
Id_Memoria = shmget (Clave, sizeof(int)*100, 0777 | IPC_CREAT);
if (Id_Memoria == -1)
{
cout << "No consigo Id para memoria compartida" << endl;
exit (0);
}
//
// Una vez creada la memoria, hacemos que uno de nuestros punteros
// apunte a la zona de memoria recién creada. Para ello llamamos a
// shmat, pasándole el identificador obtenido anteriormente y un
// par de parámetros extraños, que con ceros vale.
//
Memoria = (int *)shmat (Id_Memoria, (char *)0, 0);
if (Memoria == NULL)
{
cout << "No consigo memoria compartida" << endl;
exit (0);
}
//
// Ya podemos utilizar la memoria.
// Escribimos cosas en la memoria. Los números de 1 a 10 esperando
// un segundo entre ellos. Estos datos serán los que lea el otro
// proceso.
//
for (i=0; i<10; i++)
{
for (j=0; j<100; j++)
{
Memoria[j] = i;
}
cout << "Escrito " << i << endl;
sleep (1);
}
//
// Terminada de usar la memoria compartida, la liberamos.
//
shmdt ((char *)Memoria);
shmctl (Id_Memoria, IPC_RMID, (struct shmid_ds *)NULL);
}
anny fernandez,
padilla xiomelis,
hoepp itamar,
wait(sem_lectores);
int_lectores= n_lectores + 1;
if(n_lectores= =1)
wait(sem_recurso);
signal(sem-lectores);
< consultar el recurso compartido>
wait(sem_lectores);
n_lectores= n_lectores_1;
if(n-lectores= =0)
signal(sem_recurso);
signal(sem-lectores);
}
Escritor () {
wait(sem_recurso);
/*se puede modificar el recurso */
signal(sem_recurso);
}
#include <sys/shm.h>
#include <iostream.h>
#include <unistd.h>
void main()
{
key_t Clave;
int Id_Memoria;
int *Memoria = NULL;
int i,j;
//
// Conseguimos una clave para la memoria compartida. Todos los
// procesos que quieran compartir la memoria, deben obtener la misma
// clave. Esta se puede conseguir por medio de la función ftok.
// A esta función se le pasa un fichero cualquiera que exista y esté
// accesible (todos los procesos deben pasar el mismo fichero) y un
// entero cualquiera (todos los procesos el mismo entero).
//
Clave = ftok ("/bin/ls", 33);
if (Clave == -1)
{
cout << "No consigo clave para memoria compartida" << endl;
exit(0);
}
//
// Creamos la memoria con la clave recién conseguida. Para ello llamamos
// a la función shmget pasándole la clave, el tamaño de memoria que
// queremos reservar (100 enteros en nuestro caso) y unos flags.
// Los flags son los permisos de lectura/escritura/ejecucion
// para propietario, grupo y otros (es el 777 en octal) y el
// flag IPC_CREAT para indicar que cree la memoria.
// La función nos devuelve un identificador para la memoria recién
// creada.
//
Id_Memoria = shmget (Clave, sizeof(int)*100, 0777 | IPC_CREAT);
if (Id_Memoria == -1)
{
cout << "No consigo Id para memoria compartida" << endl;
exit (0);
}
//
// Una vez creada la memoria, hacemos que uno de nuestros punteros
// apunte a la zona de memoria recién creada. Para ello llamamos a
// shmat, pasándole el identificador obtenido anteriormente y un
// par de parámetros extraños, que con ceros vale.
//
Memoria = (int *)shmat (Id_Memoria, (char *)0, 0);
if (Memoria == NULL)
{
cout << "No consigo memoria compartida" << endl;
exit (0);
}
//
// Ya podemos utilizar la memoria.
// Escribimos cosas en la memoria. Los números de 1 a 10 esperando
// un segundo entre ellos. Estos datos serán los que lea el otro
// proceso.
//
for (i=0; i<10; i++)
{
for (j=0; j<100; j++)
{
Memoria[j] = i;
}
cout << "Escrito " << i << endl;
sleep (1);
}
//
// Terminada de usar la memoria compartida, la liberamos.
//
shmdt ((char *)Memoria);
shmctl (Id_Memoria, IPC_RMID, (struct shmid_ds *)NULL);
}
anny fernandez,
padilla xiomelis,
hoepp itamar,
Anny Fernandez- Mensajes : 9
Puntos : 11
Reputación : 0
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
profe se lo mande 2 veces por que en el 1 no l puse los integrantes
y no se lo pude mandar ayer xq cuando se lo iva a mandar se me fue el internet. gracias profe y disculpe la molestia de verdad.
y no se lo pude mandar ayer xq cuando se lo iva a mandar se me fue el internet. gracias profe y disculpe la molestia de verdad.
Anny Fernandez- Mensajes : 9
Puntos : 11
Reputación : 0
Fecha de inscripción : 05/05/2010
Re: Publiquen aqui el ejercicio de memoria compartida
lector( ) {
wait(sem_lectores);
int_lectores= n_lectores + 1;
if(n_lectores= =1)
wait(sem_recurso);
signal(sem-lectores);
< consultar el recurso compartido>
wait(sem_lectores);
n_lectores= n_lectores_1;
if(n-lectores= =0)
signal(sem_recurso);
signal(sem-lectores);
}
Escritor () {
wait(sem_recurso);
/*se puede modificar el recurso */
signal(sem_recurso);
}
#include <sys/shm.h>
#include <iostream.h>
#include <unistd.h>
void main()
{
key_t Clave;
int Id_Memoria;
int *Memoria = NULL;
int i,j;
//
// Conseguimos una clave para la memoria compartida. Todos los
// procesos que quieran compartir la memoria, deben obtener la misma
// clave. Esta se puede conseguir por medio de la función ftok.
// A esta función se le pasa un fichero cualquiera que exista y esté
// accesible (todos los procesos deben pasar el mismo fichero) y un
// entero cualquiera (todos los procesos el mismo entero).
//
Clave = ftok ("/bin/ls", 33);
if (Clave == -1)
{
cout << "No consigo clave para memoria compartida" << endl;
exit(0);
}
//
// Creamos la memoria con la clave recién conseguida. Para ello llamamos
// a la función shmget pasándole la clave, el tamaño de memoria que
// queremos reservar (100 enteros en nuestro caso) y unos flags.
// Los flags son los permisos de lectura/escritura/ejecucion
// para propietario, grupo y otros (es el 777 en octal) y el
// flag IPC_CREAT para indicar que cree la memoria.
// La función nos devuelve un identificador para la memoria recién
// creada.
//
Id_Memoria = shmget (Clave, sizeof(int)*100, 0777 | IPC_CREAT);
if (Id_Memoria == -1)
{
cout << "No consigo Id para memoria compartida" << endl;
exit (0);
}
//
// Una vez creada la memoria, hacemos que uno de nuestros punteros
// apunte a la zona de memoria recién creada. Para ello llamamos a
// shmat, pasándole el identificador obtenido anteriormente y un
// par de parámetros extraños, que con ceros vale.
//
Memoria = (int *)shmat (Id_Memoria, (char *)0, 0);
if (Memoria == NULL)
{
cout << "No consigo memoria compartida" << endl;
exit (0);
}
//
// Ya podemos utilizar la memoria.
// Escribimos cosas en la memoria. Los números de 1 a 10 esperando
// un segundo entre ellos. Estos datos serán los que lea el otro
// proceso.
//
for (i=0; i<10; i++)
{
for (j=0; j<100; j++)
{
Memoria[j] = i;
}
cout << "Escrito " << i << endl;
sleep (1);
}
//
// Terminada de usar la memoria compartida, la liberamos.
//
shmdt ((char *)Memoria);
shmctl (Id_Memoria, IPC_RMID, (struct shmid_ds *)NULL);
}
anny fernandez,
padilla xiomelis,
hoepp itamar,
wait(sem_lectores);
int_lectores= n_lectores + 1;
if(n_lectores= =1)
wait(sem_recurso);
signal(sem-lectores);
< consultar el recurso compartido>
wait(sem_lectores);
n_lectores= n_lectores_1;
if(n-lectores= =0)
signal(sem_recurso);
signal(sem-lectores);
}
Escritor () {
wait(sem_recurso);
/*se puede modificar el recurso */
signal(sem_recurso);
}
#include <sys/shm.h>
#include <iostream.h>
#include <unistd.h>
void main()
{
key_t Clave;
int Id_Memoria;
int *Memoria = NULL;
int i,j;
//
// Conseguimos una clave para la memoria compartida. Todos los
// procesos que quieran compartir la memoria, deben obtener la misma
// clave. Esta se puede conseguir por medio de la función ftok.
// A esta función se le pasa un fichero cualquiera que exista y esté
// accesible (todos los procesos deben pasar el mismo fichero) y un
// entero cualquiera (todos los procesos el mismo entero).
//
Clave = ftok ("/bin/ls", 33);
if (Clave == -1)
{
cout << "No consigo clave para memoria compartida" << endl;
exit(0);
}
//
// Creamos la memoria con la clave recién conseguida. Para ello llamamos
// a la función shmget pasándole la clave, el tamaño de memoria que
// queremos reservar (100 enteros en nuestro caso) y unos flags.
// Los flags son los permisos de lectura/escritura/ejecucion
// para propietario, grupo y otros (es el 777 en octal) y el
// flag IPC_CREAT para indicar que cree la memoria.
// La función nos devuelve un identificador para la memoria recién
// creada.
//
Id_Memoria = shmget (Clave, sizeof(int)*100, 0777 | IPC_CREAT);
if (Id_Memoria == -1)
{
cout << "No consigo Id para memoria compartida" << endl;
exit (0);
}
//
// Una vez creada la memoria, hacemos que uno de nuestros punteros
// apunte a la zona de memoria recién creada. Para ello llamamos a
// shmat, pasándole el identificador obtenido anteriormente y un
// par de parámetros extraños, que con ceros vale.
//
Memoria = (int *)shmat (Id_Memoria, (char *)0, 0);
if (Memoria == NULL)
{
cout << "No consigo memoria compartida" << endl;
exit (0);
}
//
// Ya podemos utilizar la memoria.
// Escribimos cosas en la memoria. Los números de 1 a 10 esperando
// un segundo entre ellos. Estos datos serán los que lea el otro
// proceso.
//
for (i=0; i<10; i++)
{
for (j=0; j<100; j++)
{
Memoria[j] = i;
}
cout << "Escrito " << i << endl;
sleep (1);
}
//
// Terminada de usar la memoria compartida, la liberamos.
//
shmdt ((char *)Memoria);
shmctl (Id_Memoria, IPC_RMID, (struct shmid_ds *)NULL);
}
anny fernandez,
padilla xiomelis,
hoepp itamar,
Anny Fernandez- Mensajes : 9
Puntos : 11
Reputación : 0
Fecha de inscripción : 05/05/2010
Página 1 de 1.
Permisos de este foro:
No puedes responder a temas en este foro.
Miér Mar 23, 2022 4:06 pm por VictorMora
» saludoos y geovision
Mar Ago 21, 2012 3:16 pm por jguedez99
» Gracias por el foro......
Lun Ago 13, 2012 6:31 pm por antxon
» Ejercicios de algoritmos
Miér Mar 23, 2011 5:48 am por Luis Hurtado
» Planificacion y Plan de evaluacion
Vie Mar 18, 2011 9:22 pm por Katerine D Gutièrrez
» Asignacion Nro 1
Jue Mar 17, 2011 8:46 am por Luis Hurtado
» Dccionario de Terminos informaticos
Vie Ene 28, 2011 9:53 pm por Pedro Guzman xD
» Diccionario de palabras y expresiones informaticas
Jue Ene 27, 2011 8:02 pm por Julio Quiroz
» Asignación Glosario
Miér Ene 26, 2011 6:37 am por Luis Hurtado