YT YouTube2Text

YouTube2Text → Transcripts → Semáforos POSIX Sin Nombre en Procesos Independientes, ejemplo en lenguaje C

Semáforos POSIX Sin Nombre en Procesos Independientes, ejemplo en lenguaje C — Transcript

by juancarlosjromer · 3,046 words · 522 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00Bueno, muy buenos días. Hoy vamos a
0:02hacer un ejemplo con semáforos POSIX sin
0:05nombre en procesos independientes, así
0:08que bueno, vamos a explicar un poquito
0:10cómo se componen los procesos y después
0:12vamos a mostrar los códigos y los vamos
0:14a ejecutar.
0:15Bueno, adelante.
0:17Vamos a mostrar un ejemplo en lenguaje C
0:20con el objetivo de mostrar el uso de los
0:22semáforos POSIX sin nombre en procesos
0:25independientes.
0:27Vamos a hacer un ejemplo simple del
0:28punto de vista de la lógica
0:30para concentrarnos en los pasos que
0:33debemos ejecutar en los procesos para
0:36poder usar estos semáforos POSIX sin
0:39nombre.
0:41Bueno, aquí vemos la secuencia de
0:42ejecución de la sección crítica por
0:45parte del proceso A y el proceso B y esa
0:48sincronización nos va a permitir hacer
0:50una secuencia de ejecución PA PB PA PB
0:54PA PB PA PB. Sí, ese es el orden que eh
0:58la sincronización tiene que mantener
1:00para que los procesos eh accedan a su
1:02sección crítica casualmente en esa
1:05secuencia.
1:07Tenemos un proceso que se llama Create
1:10Shared Memory que lo vamos a utilizar
1:12casualmente para crear la memoria
1:14compartida.
1:15Este proceso eh vamos a tener tres pasos
1:18en términos generales. El primer paso es
1:21definir una estructura que va a tener
1:24dos variables de tipo de dato sem_t,
1:28o sea, semáforo POSIX.
1:31Eh decimos dos semáforos porque bueno,
1:33la sincronización PA PB PA PB va a
1:35necesitar mínimamente dos semáforos.
1:38El segundo paso es crear la memoria
1:40compartida POSIX para poder almacenar
1:43dicha estructura, o sea, que la
1:45estructura se va a almacenar en una
1:47memoria compartida y una memoria
1:48compartida POSIX, casualmente.
1:51Sí.
1:52Y el tercer paso es ajustar el tamaño de
1:55la memoria compartida al tamaño de la
1:57estructura que contiene los dos
2:00semáforos POSIX que nos va a servir, que
2:02nos van a servir para hacer esta
2:04sincronización.
2:06Vamos a tener un proceso eh que vamos a
2:08llamar initsem, que lo que va a hacer es
2:11inicializar los semáforos
2:13de manera tal que el semáforo A esté
2:18inicializado en uno y el semáforo B esté
2:20inicializado en cero.
2:22¿Sí?
2:23Para ello
2:24tenemos cuatro pasos: definir la
2:27estructura, que también se definió en el
2:30proceso create shared memory. Por
2:32supuesto que eh yo estoy repitiendo la
2:35estructura en cada uno de los procesos
2:37para que sea más simple para aquellos
2:39programadores que no son tan
2:40experimentados, pero bueno, un
2:42programador experimentado podría no
2:44repetir la estructura en cada proceso y
2:47guardar la estructura en un archivo de
2:49cabecera y después incluirlo en los
2:52otros procesos, pero bueno, eh este
2:55código está hecho para que se entienda.
2:58¿Sí? Entonces, eh este proceso initsem
3:01también va a definir la estructura que
3:04definió eh el proceso create shared.
3:07Después tenemos el apertura de la
3:10memoria compartida POSIX, que ya debería
3:12estar creada, si no la ejecución de este
3:16proceso va a dar error en ese paso.
3:19¿Sí? Después hay que mapear la memoria
3:21compartida en el espacio de direcciones
3:24del proceso de usuario. En este caso
3:26vamos a mapear el área de memoria
3:29compartida en el espacio de direcciones
3:31del proceso initsem
3:33para que pueda tener acceso a los
3:35semáforos, por supuesto, ¿no? Y después,
3:37bueno, el cuarto paso, inicializar los
3:40semáforos, ¿sí? Como dijimos antes, el
3:42semáforo A en uno y el semáforo B en
3:45cero.
3:47Por supuesto que vamos a tener el
3:49proceso PA
3:50que eh también va a definir la
3:52estructura y contiene los semáforos
3:54porque, eh, digamos, no usamos un
3:56archivo de cabecera.
3:58Eh, de la misma manera, el proceso PA va
4:00a tener que abrir la memoria compartida
4:02POSIX, igual que lo hizo el proceso
4:04initsem.
4:05También va a tener que mapear la memoria
4:07compartida dentro del espacio de
4:09direcciones del proceso de usuario PA.
4:12Y la diferencia está en el paso cuatro y
4:15cinco, que el proceso PA, por supuesto,
4:17va a tener que definir la sección de
4:18entrada a la sección crítica y va a
4:21tener que definir la, eh, salida, o sea,
4:25la sección de salida de la sección
4:26crítica, ¿sí?
4:28Por supuesto que vamos a tener un
4:29proceso PB y los pasos del proceso PB
4:32son los mismos pasos que el proceso A.
4:35¿Sí?
4:37Y por último, vamos a tener un proceso
4:39que llama Elimina Shared Memory, eh, que
4:42es un proceso muy simple y, de una línea
4:45de código.
4:46Eh, bueno, este proceso va a eliminar la
4:49shared memory, la memoria compartida.
4:53Bien, comenzamos a meternos más a nivel
4:55de detalle. Acá vemos el paso uno del
4:58proceso Crea Shared Memory, que era
5:00definir la estructura con los semáforos.
5:03Le pueden poner el nombre que quieran,
5:04yo le puse estructura, estruc, semáforo,
5:07le puse semáforos al, al estructura y,
5:10como ustedes ven, tienen dos tipos de
5:11dato, eh, sem_t.
5:14Eh, el primer tipo de dato sem_t, eh,
5:18define una variable que llamamos SA, le
5:21pueden poner el nombre que quieran.
5:23Y el segundo tipo sem_t define la
5:26variable SB y, repito, le pueden poner
5:29el nombre que quieran. Bueno, ahí
5:31tenemos la estructura que ahora vamos a
5:33usar.
5:35Bien, aquí estamos en el paso dos del
5:37proceso Crea Shared Memory.
5:39El proceso tiene que hacer una llamada
5:41al sistema Shared Memory Open.
5:43El primer argumento de la llamada es un
5:47cons char asterisco, eh es una cadena de
5:51caracteres y le recomendamos que el
5:53primer carácter sea una barra, ¿sí?
5:56Para, digamos, facilitar la la
5:58implementación.
6:00El segundo argumento son los flags de
6:02creación,
6:03create exclusivo y read write, eh create
6:08combinado con exclusivo lo que hace es,
6:11eh si ya existe el share memory open,
6:16y, bueno, el el o guion bajo read write,
6:19open read write, este, crea el área de
6:23memoria compartida para lectura y
6:24escritura.
6:25Y el tercer argumento son los modos de
6:28creación, en este caso, eh le das
6:32permiso de usuario al le da permiso al
6:34proceso de usuario para que pueda leer
6:37eh la memoria compartida y le da permiso
6:40al proceso de usuario para que pueda
6:42escribir la lec eh la memoria
6:44compartida, ¿sí?
6:47Bien, el paso tres del proceso crea
6:49share memory
6:51es llamar a la función ftruncate y de
6:53que tiene el primer argumento
6:56es lo que me devuelve el share memory
6:58open, es un entero, y el segundo
7:00argumento es eh la longitud de la
7:03estructura semáforos, ¿sí? De esta
7:05manera ajusta el tamaño de la memoria
7:07compartida a el tamaño de la estructura
7:10que va a guardar en esa memoria, ¿sí?
7:14Bien, acá tenemos el paso uno del
7:15proceso init sem,
7:17eh el primer paso es eh llamar a share
7:21memory open y la única diferencia que
7:23hay en el la llamada de init sem con
7:25respecto a la llamada de crea share
7:27memory
7:29es eh el segundo argumento. En este
7:32caso, ya el área de memoria compartida
7:34está creada, así que los flags de
7:37creación y de exclusivo no van,
7:39solamente en el segundo argumento va el
7:42flag de open the rewrite, nada más.
7:45Después el primer argumento y el tercer
7:47argumento son iguales.
7:49El paso dos del proceso init sem es el
7:51mapeo de la memoria compartida.
7:54La llamada al sistema es mmap y el
7:57primer argumento es la dirección de
7:58mapeo.
7:59Si ponemos null, eh, le decimos al
8:02sistema operativo que él, este,
8:05encuentre una dirección de mapeo. Así
8:08que bueno, es lo más conveniente.
8:10El segundo argumento es la longitud de
8:12la memoria a mapear, en este caso es la
8:15longitud o el tamaño del struct
8:17semáforos y por supuesto que el segundo
8:19argumento tiene que ser mayor que cero.
8:22El tercer argumento se refiere a la
8:24protección de memoria
8:26y ahí, eh, aparece prot read y prot
8:29write, eso quiere decir que las páginas
8:32de la memoria mapeada pueden leerse y
8:35las páginas de la memoria mapeada pueden
8:37escribirse.
8:39Eh, bueno, acá aparece el concepto de
8:41páginas, para entender lo que es el
8:43concepto de páginas hay que estudiar
8:45administración de memoria paginada.
8:47Así que lo vamos a dejar por el momento
8:49ese concepto.
8:51El cuarto argumento es un flag que
8:53indica que esta área de memoria mapeada
8:56se puede compartir, o sea, que si algún
8:59proceso que está mapeado sobre esta área
9:02de memoria hace una actualización, los
9:04demás procesos que están mapeados a esta
9:06misma área de memoria también van a ver
9:08las actualizaciones a las modificaciones
9:10que se hagan.
9:13El quinto argumento es el entero
9:15retornado por el share memory open
9:18y está indicando que vamos a mapear la
9:19memoria compartida.
9:22El sexto argumento
9:24es un desplazamiento dentro de la
9:26memoria compartida
9:28que indica a partir de qué
9:30desplazamiento se va a mapear la memoria
9:31compartida.
9:33En este caso cero está indicando un
9:35desplazamiento relativo a cero, o sea,
9:37un desplazamiento relativo al comienzo
9:41de la memoria compartida.
9:44El paso tres del proceso init sem es eh
9:46usar la llamada sem init. El primer
9:49argumento de la llamada sem init es la
9:51dirección de memoria de la variable
9:53correspondiente al semáforo.
9:57Esa variable está en la estructura
10:00mapeada en la dirección shm.
10:04¿Sí? Entonces, desde la dirección shm
10:08hacemos la referencia SA y ahí tomamos
10:11la dirección de SA, lo mismo para SB. El
10:15segundo argumento es eh un uno en este
10:19caso o algo distinto de cero,
10:22indicando que el semáforo se puede
10:24compartir entre procesos independientes.
10:27Si el segundo argumento fuera cero, el
10:30semáforo no se podría compartir,
10:32entonces habría que usarlo en un ámbito
10:34de hilos.
10:35Y el tercer argumento es el valor de
10:38inicialización del semáforo. En ese
10:40caso, el semáforo A lo inicializamos en
10:42uno y el semáforo B lo inicializamos en
10:45cero.
10:46Bien, el paso uno del proceso A
10:49es hacer la llamada a shm open y tiene
10:53el mismo formato que eh la que usó el
10:56proceso eh init sem, ¿sí? Porque el
10:59proces, perdón, porque la memoria
11:01compartida en este caso ya debería estar
11:03creada, así que no nos vamos a detener a
11:06explicarlo.
11:08El segundo paso del proceso PA es hacer
11:10la llamada mmap, o sea, mapear la
11:13mapear la memoria compartida
11:16eh y tiene el mismo formato que el mmap
11:19del proceso init sem, así que tampoco
11:22nos vamos a detener a explicarlo.
11:24El paso tres del proceso A es hacer la
11:27llamada sem wait sobre el semáforo A y
11:30hacer la llamada sem post sobre semáforo
11:33B.
11:33Bueno, el argumento de semwait es la
11:36dirección de memoria deseada, que por
11:39supuesto está referenciada por la
11:41dirección SHM.
11:43Si quieren entender un poquito más los
11:46símbolos ampersand y la flechita, pueden
11:48ver los vídeos que están en mi canal,
11:51que comienzan
11:52con el nombre Taller de C. Son los
11:54últimos cinco vídeos. Ahí explico el
11:56ampersand y explico la flechita, qué
11:58significa. La cuestión es que
12:01semwait, este, funciona como explican
12:04los libros de sistemas operativos la
12:07operación wait, y sempost funciona como
12:09explican los libros de sistemas
12:11operativos sobre, eh, las, digamos, las
12:15llamadas signal, ¿sí? O la operación
12:17signal sobre semáforos.
12:20Estamos viendo los pasos del proceso B.
12:22Los pasos uno y dos son iguales en el
12:25proceso A y en el proceso B.
12:27Y en el paso tres, por supuesto, lo
12:29único que cambia es, este, el wait, que
12:32ahora el proceso B tiene que hacer un
12:34semwait sobre el semáforo B
12:36y, eh, tiene que hacer un sempost sobre
12:38el semáforo A para que la sincronización
12:41funcione.
12:43Bien, aquí vemos el proceso elimina
12:45shared memory. Lo único que hace es una
12:46llamada shared memory unlink
12:49y el argumento es, eh, el string, mmm,
12:51la cadena que hace referencia a la
12:54memoria compartida, ¿sí? El mismo string
12:56que se usó en el shared memory open, en
12:59la creación de la memoria compartida.
13:01Bueno, ese, esa llamada shared memory
13:03unlink
13:05entonces, elimina el recurso.
13:09Bien, acá estamos viendo los pasos de
13:11compilación y vemos las líneas de
13:13compilación de cada uno de los procesos.
13:16Algunas líneas de compilación, eh,
13:18vinculan a la librería RT y algunas
13:21líneas de compilación vinculan a la
13:23librería RT y pthread.
13:26Pthread es para, eh lo que es el uso de
13:30llamadas para semáforos y RT es eh lo
13:34necesito para llamadas eh relacionadas
13:37con la memoria compartida, ¿sí?
13:41Bien, aquí estamos ya en el Raspbian. Eh
13:44vamos a ver un poquito cada uno de los
13:47procesos, sí, vamos a empezar con crea
13:49shared memory, ¿sí?
13:55Bien.
13:57Acá tenemos el código de crea shared
13:59memory. Bueno, todos los include que
14:02tenemos que hacer para las llamadas al
14:05sistema y las funciones que vamos a
14:06utilizar. Aquí está la estructura
14:09semáforos, ¿sí?
14:11Con eh la variable
14:13la variable SA
14:15de tipo sem_t
14:18y la variable SB de tipo sem_t, ¿sí?
14:22Semáforos posix sin nombre.
14:24Después tenemos en en el main tenemos eh
14:27la llamada a shared memory open, como lo
14:31dijimos ya previamente, devuelve un
14:33entero que sería el file eh descriptor
14:37de del objeto shared del objeto memoria
14:40compartida.
14:41Si es -1, entonces mostramos error eh
14:44shared memory memory open y terminamos.
14:48Si no dio error el shared memory open,
14:50que en este caso es crearla de forma
14:52exclusiva de lectura y escritura con los
14:55permisos este eh de lectura para el
14:58usuario y de escritura para el usuario,
15:01entonces si no da error, entonces
15:03ajustamos el tamaño de la memoria
15:05este como ya lo explicamos. Entonces
15:07usamos la función ftruncate, ¿sí? Le
15:10pasamos lo que nos devolvió eh shared
15:12memory open y el tamaño de la estructura
15:16semáforos. Si da error, entonces
15:19mostramos que dio error y terminamos el
15:22proceso. Y si no
15:23dio error
15:25mostramos memoria compartida posix
15:26creada y termina el proceso. Entonces
15:28acá tenemos la llamada share share
15:31memory open para crear y la función
15:35ftruncate para ajustar.
15:38¿Sí? Bien.
15:41Vamos a ver ahora init init sem.
15:52Muy bien, todas las cabeceras que
15:53tenemos que usar,
15:55la estructura,
15:57¿sí? Acuérdense lo que dijimos hoy.
15:59Dijimos, bueno, esto lo podríamos poner
16:01en un punto h también con todas las con
16:03todos los include, con todas las
16:04cabeceras, pero bueno, me parece que así
16:07se entiende un poco más.
16:09Eh entonces, bueno, declaramos la
16:11estructura de la misma manera que lo
16:13hicimos en el código de create share
16:15memory.
16:18Hacemos la apertura de la memoria
16:20compartida.
16:21Como ya lo explicamos, si da error, de
16:24nuevo mostramos en pantalla el mensaje y
16:27terminamos. Y si no da error, mapeamos,
16:30mapeamos el mmap, entonces nos devuelve
16:34un puntero
16:36a una estructura semáforos, o sea, nos
16:38devuelve una dirección de memoria
16:40a una estructura semáforos. Ese es el
16:42mapeo.
16:43¿Sí? Acuérdense lo que dijimos del
16:45mapeo, ¿no?
16:47Bueno, si da error, por supuesto,
16:49entonces mostramos un un mensaje en
16:51pantalla y termina el proceso.
16:54Y acá tenemos, como lo explicamos
16:55también, la inicialización de los
16:57semáforos, ¿sí?
16:59Si todo esto sale bien, entonces
17:01semáforos posix sin nombre
17:03inicializados. Si no,
17:05terminará
17:06en el error que dio en este caso share
17:09memory open, si lo da, el mmap, si lo
17:12da, el sem_init para el semáforo a, si
17:14da error, o el sem_init para el semáforo
17:17B, si agarro, ¿sí?
17:18Bien.
17:21Vamos a ver ahora el código del proceso
17:24A.
17:29De nuevo, acá
17:31declaramos la estructura semáforos,
17:33hacemos el open de la shared memory, tal
17:36cual lo hizo initsem, hacemos el mapeo
17:39de la memoria compartida en el espacio
17:41de direcciones del proceso,
17:43tal cual lo hizo initsem, y acá tenemos
17:46entonces el comienzo de la
17:48sincronización, un ciclo infinito,
17:51sí, ahí tenemos un ciclo infinito,
17:53sí, donde el proceso A lo único que va a
17:55decir sección crítica de PA, ¿sí?
17:58Y la sección de entrada entonces, como
18:00también ya lo explicamos, es el semwait
18:03sobre el semáforo A.
18:05Y la sección de salida es el sempost
18:08sobre el semáforo B.
18:13Ahora tenemos el proceso B, que es igual
18:17al proceso A,
18:19¿sí?
18:20Pero con la diferencia de que el semwait
18:23ahora es sobre el semáforo B y el
18:25sempost es sobre el semáforo A.
18:30Vemos el elimina shared memory.
18:40Fíjense que lo único que hace elimina
18:42shared memory es
18:43el shared memory unlink, ¿sí? De eh
18:47digamos el string de creación de la
18:50shared memory, ¿sí? Acá no hay que
18:52declarar la estructura semáforos,
18:55este, así que no no lo pusimos.
19:02Bien, vamos a mostrar
19:04compilar.
19:14Acá están las líneas de compilación de
19:16cada uno de los códigos. Crea shared
19:19memory, necesita la librería RT.
19:23Init sem necesita librería p3d y RT, PA
19:26necesita p3d y RT, PB necesita p3d y RT
19:31y RT y elimina shared memory RT.
19:35Así que
19:37bien.
19:38Bueno, vamos a compilar.
19:43Ahí compilamos, creó todos los
19:46ejecutables, ¿sí?
19:51Ahí tenemos todos los ejecutables, crea
19:53shared memory,
19:55elimina shared memory, init sem,
19:58proceso A, proceso B, ¿sí?
20:01Bien, vamos a eh abrir otra terminal.
20:09Ahí está.
20:14Bien, vamos a achicar esta.
20:24Vamos a limpiar la pantalla.
20:28Vamos a
20:33Bueno, bueno, eh en la terminal de la
20:36derecha vamos a ejecutar el proceso B,
20:39PB.
20:40Y ahí se ve ah, perdón, muy bien, me
20:42olvidé, me olvidé de algo, no puedo
20:44ejecutar PB porque tengo que crear la
20:46memoria compartida, entonces, pero voy a
20:48ejecutar elimina primero.
20:51Fíjense que si ejecuto elimina, elimina
20:54me dice memoria compartida no existe.
20:57Así que voy a crear la memoria
20:58compartida.
21:00Ahí está, memoria compartida pues sí
21:02creada. Si ahora ejecuto elimina,
21:05entonces memoria compartida eliminada,
21:08así que la voy a crear de nuevo.
21:10Ahí está, bien, memoria compartida posix
21:13creada. Ahora por supuesto tengo que
21:15hacer init.
21:16Bien, semáforos posix sin nombre
21:19inicializados, perfecto, entonces tengo
21:21la memoria compartida creada.
21:23Tengo los semáforos posix sin nombre
21:25inicializados,
21:27así que ahora lo que voy a hacer si
21:29ejecutar el proceso PB.
21:31Ahí está.
21:32PB share memory open devuelve file
21:35descriptor 3.
21:37Y ahora ejecuto PA.
21:41Sección crítica de A, sección crítica de
21:43B, bueno, AB AB, si le pusimos el sleep
21:461 para que se vea en la pantalla.
21:48Bien la sincronización, ¿no?
21:51Bueno, listo y ahí se van a quedar hasta
21:53el infinito, así que con esto mostramos,
21:55la idea era mostrar eh.
21:58Cómo implementar los semáforos posix sin
22:01nombre en eh procesos independientes,
22:04así que bueno. Espero que les sirva y
22:06dejamos ahí que el proceso A y el
22:08proceso B sigan hacia el infinito y el
22:11más allá, chao chao.

About this transcript

This page contains the full transcript of Semáforos POSIX Sin Nombre en Procesos Independientes, ejemplo en lenguaje C by juancarlosjromer, generated from the public captions YouTube serves with the video. The transcript has 3,046 words across 522 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.