La memoria compartida es muy \u00fatil para programas que subprocesos con fork, sin embargo no necesariamente es ese su l\u00edmite, la memoria compartida igual puede ser usada por programas totalmente distintos como un medio para enviarse se\u00f1ales y compartir informaci\u00f3n en com\u00fan.<\/p>\n
Solo hay un problema, todo kernel decente tiene protecci\u00f3n de memoria, esto significa que un programa no puede interferir con otro, as\u00ed que el hecho de que 2 o m\u00e1s programas intenten entrar a la misma zona de memoria es contradictorio, por lo que el sistema operativo as\u00ed de gusto no lo va a permitir, salvo sea el mismo sistema operativo quien nos ayude a esto.<\/p>\n
Para mostrar c\u00f3mo es posible hacer esto, hare 3 programas, podr\u00edan ser al menos 2, pero la intenci\u00f3n es mostrar que muchos programas pueden operar con los mismos segmentos de memoria.<\/p>\n
El primer programa reservada la memoria y ser\u00e1 el encargado de liberarla tambi\u00e9n, mientras este programa este corriendo los otros 2 podr\u00e1n accesar a la memoria compartida.<\/p>\n
El segundo programa accesara a la memoria compartida e ir\u00e1 haciendo modificaciones en dicha zona, ser\u00e1 un contador.<\/p>\n
El tercer programa leer\u00e1 la zona de memoria y nos mostrara el valor actual que hay en ella.<\/p>\n
Los 3 programas ser\u00e1n muy similares, las funciones se explican a continuaci\u00f3n.<\/p>\n
Para que programas completamente independientes compartan informaci\u00f3n, deben tener un acceso com\u00fan a un recursos del sistema, estos programas crean si no existe un archivo en el temporal y se ligaran a el para crear una llave<\/p>\n
La llave se asigna a una variable tipo key_t usando la funci\u00f3n ftok, ftok requiere 2 parametros , el archivo en com\u00fan que hemos creado y un entero, esto debe coincidir en cada programa que vaya a usar la zona de memoria, de lo contrario el sistema operativo les negara el acceso tal cual debe ser.<\/p>\n
Obtenemos la clave con el siguiente ejemplo.<\/p>\n
key_t clavecompartida = ftok (“\/tmp\/acompartido”,33);<\/p>\n
una vez con la clave solicitamos al sistema operativo cree una zona de memoria de 400 bytes, un apuntador tipo char de 100 veces su tama\u00f1o. Esto nos devolver\u00e1 un entero con el identificador del segmento de memoria, si la asignaci\u00f3n tuvo \u00e9xito.
\nint mem = shmget (clavecompartida,sizeof(char *)*100,0777 | IPC_CREAT);<\/p>\n
N\u00f3tese que la protecci\u00f3n de memoria es similar a la protecci\u00f3n de acceso a archives, el par\u00e1metro 0777 tiene el mismo significado que los permisos de archivo, de esta forma estamos declarando que nuestra memoria ser\u00e1 de acceso total para todos, tambi\u00e9n podr\u00edamos dar permisos de solo lectura para determinados programas que corran con X usuario, como solo lectura o negarle el acceso a cualquier otro usuario que quiera entrar a nuestra memoria compartida, el IPC_CREAT Solo lo usamos al momento de buscar reservar o crear el espacio, para leer o modificar la memoria en otros programas no ser\u00e1 necesario, porque ya existir\u00e1.<\/p>\n
Ya con el identificador entraremos a la zona de memoria v\u00eda punteros, al puntero lo alimentamos con la funci\u00f3n shmat a la cual le pasamos como par\u00e1metro el identificador de nuestra zona de memoria<\/p>\n
char *mcompartida = (char *) shmat (mem,NULL,0);<\/p>\n
En este punto, el puntero char mcompartida est\u00e1 ligado a la memoria compartida y lo que le hagamos a ese puntero, lo estamos haciendo en esa zona de memoria.<\/p>\n
Aclarando que es mas f\u00e1cil mover cadenas de caracteres por ese punto, por lo que si queremos pasar n\u00fameros, por ejemplo un 10, sera mas f\u00e1cil enviar una cadena de caracteres \u201c10\u201d y al recibirla en otro programa, convertirla en un entero, por ejemplo<\/p>\n
Strcpy (mcompartida,\u201d10\u201d);<\/p>\n
Liberando la memoria compartida y borrando el archivo en com\u00fan, con la funci\u00f3n shmctl y pas\u00e1ndole el primer par\u00e1metro la variable entera que tiene el identificador de la zona de memoria<\/p>\n
shmctl (mem, IPC_RMID, (struct shmid_ds *)NULL);<\/p>\n
unlink (\u201carchivo\u201d);<\/p>\n
unlink borra archives del sistema operativo<\/p>\n
Si el programa terminara de forma incorrecta o por interrupci\u00f3n del usuario, la memoria compartida se quedara en el sistema operativo indefinidamente, ya que el programa nunca le notifico al sistema operativo que deb\u00eda liberarla.<\/p>\n
En el caso de GNU\/Linux los comandos ipcs nos ayudaran a administrar manualmente las zonas compartidas de memoria.<\/p>\n
Si queremos ver cu\u00e1ntas memorias compartidas hay, usamos el comando ipcs<\/p>\n
Por ejemplo si queremos borrar la zona 1234 usamos el Ipcrm \u2013m 1234<\/p>\n
Ahora el c\u00f3digo de 3 programas que demuestran el acceso a la memoria compartida.<\/p>\n
Asignar.c Este programa reserva y libera la memoria, mientras se ejecute los otros 2 programas tendr\u00e1n acceso a la memoria.
\n#include <stdio.h>
\n#include <sys\/shm.h><\/p>\n
int main ()
\n{
\n FILE *archivocompartido;
\n key_t clavecompartida;
\n int mem = 0;
\n char *mcompartida = NULL;<\/p>\n
archivocompartido = fopen
\n(“\/tmp\/acompartido”,”w+”);
\n clavecompartida = ftok
\n(“\/tmp\/acompartido”,33);<\/p>\n
mem = shmget
\n(clavecompartida,sizeof(char *)*100,0777 | IPC_CREAT);
\n mcompartida = (char *) shmat
\n(mem,NULL,0);<\/p>\n
printf (“Creando el segmento
\n%d de memoria compartida\\n\\n”,mem);
\n printf (“Precione ENTER para
\nliberar los recursos compartidos\\n”);<\/p>\n
getchar ();<\/p>\n
shmctl (mem, IPC_RMID,
\n(struct shmid_ds *)NULL);
\n unlink (“\/tmp\/acompartido”);
\n return 0;
\n}<\/p>\n
Modificar.c Este programa modifica la zona de memoria asignada por asignar.c
\n#include <stdio.h>
\n#include <sys\/shm.h><\/p>\n
int main ()
\n{
\n FILE *archivocompartido;
\n key_t clavecompartida;
\n int mem = 0;
\n int contador = 0;
\n char *mcompartida = NULL;<\/p>\n
archivocompartido = fopen
\n(“\/tmp\/acompartido”,”w+”);
\n clavecompartida = ftok
\n(“\/tmp\/acompartido”,33);<\/p>\n
mem = shmget
\n(clavecompartida,sizeof(char *)*100,0777);
\n mcompartida = (char *)
\nshmat (mem,NULL,0);<\/p>\n
printf (“Trabjando con el
\nsegmento: %d\\n”,mem);
\n printf (“Cada segundo se
\nactualiza el valor compartido, el programa dura un minuto\\n”);<\/p>\n
while (contador != 60)
\n {
\n
\ncontador = contador + 1;
\n
\nsprintf (mcompartida,”%d”,contador);
\n
\nsleep (1);
\n }<\/p>\n
return 0;
\n}
\nObtener.c este programa obtiene el valor actual de la zona de memoria compartida<\/p>\n
#include <stdio.h>
\n#include <sys\/shm.h><\/p>\n
int main ()
\n{
\n FILE *archivocompartido;
\n key_t clavecompartida;
\n int mem = 0;
\n char *mcompartida = NULL;<\/p>\n
archivocompartido = fopen
\n(“\/tmp\/acompartido”,”w+”);
\n clavecompartida = ftok
\n(“\/tmp\/acompartido”,33);<\/p>\n
mem = shmget
\n(clavecompartida,sizeof(char *)*100,0777);
\n mcompartida = (char *)
\nshmat (mem,NULL,0);<\/p>\n
printf (“Trabajando con el
\nsegmento: %d\\n”,mem);
\n printf (“El valor compartido
\nes: %s\\n”, mcompartida);<\/p>\n
return 0;
\n}<\/p>\n
Un video mostrando la ejecuci\u00f3n de los 3 c\u00f3digos.<\/p>\n