YT YouTube2Text

YouTube2Text → Transcripts → C Linux Semáforos System V 01

C Linux Semáforos System V 01 — Transcript

by juancarlosjromer · 5,748 words · 929 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00muy buenos días bueno hoy vamos a
0:02presentar el uso de semáforos existen 5
0:06en linux bueno comencemos
0:09antes de empezar a estudiar y ver y
0:13ejercitarnos con el tema de semáforos lo
0:15primero que deberíamos hacer es entender
0:18el problema de la sección crítica si el
0:21problema de la sección crítica aparece
0:24cuando queremos comunicar procesos y
0:27específicamente en los libros está
0:30explicado en función de un proceso de
0:33producción y un proceso de consumición
0:35entonces yo les pediría por favor que
0:38antes de seguir viendo este vídeo vayan
0:42a mi página a mi canal y vean el vídeo
0:46productor consumidor 01 cuyo link les
0:49dejo en esta en esa imagen
0:52bueno a esta altura ya habrán visto el
0:55vídeo producto al consumidor 01 en mi
0:58canal así que seguimos con semáforos
1:01vamos a usar las llamadas al sistema
1:04schengen sin control y sin off
1:08la llamada sistemas en get se usa para
1:10crear un conjunto de semáforos las
1:13llamadas se encontró y se usa para hacer
1:15operaciones de control sobre semáforo no
1:18son las únicas pero nosotros vamos a
1:19usar este se encontró para inicializar
1:23para ver el contenido del bar del
1:25semáforo y para borrar este semáforo y
1:29con la llamada se move vamos a
1:33para realizar las operaciones white y
1:36signal sobre semáforos
1:39bueno ustedes saben que tome la
1:43costumbre de dejarles la primera página
1:45del manual de las llamadas al sistema
1:47que usamos simplemente para no olvidarse
1:50que tienen que leer si tienen que leer
1:53más en detalle en este caso de la
1:56llamada sistema schengen de las llamadas
1:59sistemas en control y de la llamada el
2:01sistema se move sí así que bueno a leer
2:04bueno antes de empezar lo primero que
2:06vamos a hacer es darle una ojeada al
2:09comando ipcs de linux
2:12bien aquí estamos en la línea de
2:14comandos de la consola de linux así que
2:16vamos a ejecutar el comando y pss
2:20lo que ven en pantalla es la salida del
2:23comando y pss cuando se ejecuta que nos
2:26muestra los segmentos de memoria
2:27compartida la memoria compartida es un
2:30recurso de comunicación entre procesos
2:33después nos muestra el recurso matrices
2:37de semáforos o conjuntos de semáforos
2:40que es un recurso de sincronización
2:42entre procesos y después nos muestra el
2:46recurso con la de mensajes que es un
2:48recurso de comunicación y sincronización
2:51entre procesos así que bueno nosotros
2:55nos vamos a concentrar en este vídeo
2:58en el recurso semáforo o conjunto de
3:02semáforos y así que vamos a tipear vamos
3:06a borrar la pantalla y vamos a tipear
3:08nuevamente el comando pero con el
3:10argumento s entonces ahí nos muestra
3:14solamente el recurso semáforos
3:18no hay ningún semáforo creado todavía
3:20nosotros vamos a crear semáforos así que
3:23nos muestra solamente las columnas que
3:27nos dan información sobre cada conjunto
3:29de semáforos la primera columna es una
3:33clave que le da el programador al
3:35conjunto de semáforos creados la segunda
3:39columna es el identificador del conjunto
3:43de semáforos que se lo da el sistema
3:46operativo la tercera columna nos muestra
3:49cuál es el usuario el nombre de usuario
3:52que creó el recurso
3:55la cuarta columna nos muestra los
3:57permisos que tienen esos semáforos los
4:00permisos de acceso
4:03y la última columna nos muestra la
4:05cantidad de semáforos que se crearon
4:07para el conjunto para el conjunto sí así
4:12que bueno nosotros nos vamos a dedicar a
4:14hacer más foros en este vídeo
4:17bueno ahora vamos a dar una breve
4:18explicación de
4:20y la sintaxis
4:22el single de la llamada single
4:25bien el el senguer
4:30me va a devolver un entero que
4:33casualmente ese es el
4:36y si del recurso que va a crear el
4:41sistema así después va a recibir
4:44un tipo de dato kate que es un número
4:48extra decimal de ocho dígitos de
4:52hexadecimal es como máximo nosotros en
4:54el ejemplo le vamos a pasar el número
4:57ella decimal 0 x a sí
5:00va a recibir como argumento también el
5:02sen get un entero sí que va a definir la
5:08cantidad cantidad de semáforos
5:15del conjunto sí
5:18ese es el segundo argumento un entero
5:21nosotros en el ejemplo vamos a pasar dos
5:24entonces estos serían dos semáforos
5:26dentro del conjunto identificado por el
5:30sistema con el identificador del
5:33conjunto o sea eso lo vamos abordar a
5:36una variable entera se mide y el tercer
5:40argumento que le que tiene como entrada
5:43en schengen es un entero que va a ser
5:47una combinación de flux si nosotros
5:51vamos a usar tres flag el flag ipc
5:54create
5:56ips y
5:58el flag ipc exclusivo
6:03y el tercer flag serían los permisos y
6:09serían los permisos de acceso entonces
6:14repasando el send get nos devuelve un
6:16entero que es el identificador del
6:18conjunto de recursos semáforos recibe
6:21como argumentos de entrada
6:24una clave es un número extra decimal
6:27otorgada por el programador segundo
6:30argumento la cantidad de semáforos del
6:33conjunto puede ser uno puede ser dos por
6:35eso tres pueden ser m que van a
6:37pertenecer al conjunto se mide si
6:40nosotros vamos pasar dos vamos a usar
6:42dos semáforos y el tercer argumento son
6:45los flancos que nosotros vamos a ver el
6:47flag ips create ips exclusivo y los
6:49permisos y los permisos que le vamos a
6:52pasar van a ser 60 real los permisos son
6:57600 van a ver el código un 0 adelante
7:00para indicar que este número es ok tal
7:02si los permisos en realidad es este
7:05permiso de lectura y permiso de
7:07escritura para el creador del conjunto
7:10de semáforos igual ahora lo vamos a
7:13explicar este en el código mientras en
7:16lo que íbamos
7:18bueno vamos a crear un programa para
7:21crear semáforos
7:24el programita lo vamos a llamar creación
7:26ce ya tengo parte escrita para no
7:29hacerte largo el vídeo entonces tenemos
7:32acá la cabecera para abrir la cabecera
7:35para exit la cabecera para eventuales
7:39errores capturar eventuales errores de
7:43del cen get y acá tenemos las cabeceras
7:47que nos dice el manual que tenemos que
7:49incluir bueno vamos a hacer un
7:52programita en semi se mide es una
7:55variable no es una palabra reservada ahí
7:57vamos a capturar lo que nos devuelve el
7:59single el primer argumento de schengen
8:02es
8:04la clave que le va a otorgar el
8:07programador a ese conjunto de semáforos
8:09que no es lo mismo que el semen aire el
8:11aire es el identificador que usa el
8:14sistema operativo para identificar al
8:16conjunto de semáforos el segundo
8:19argumento es en get es la cantidad de
8:21semáforo del conjunto
8:23nosotros vamos a crear dos semáforos
8:24dentro ese conjunto y ahora vienen los
8:27flag
8:29este es el primer flag que indica que
8:31cree en los semáforos
8:33este es el segundo flag
8:38qué va a indicar o mejor dicho le va a
8:41decir a la creación de semáforos que si
8:44ya existe un conjunto de semáforos con
8:47esta clave de programador si este que es
8:52en get no toque el conjunto y que
8:54retorne un error si para no borrar los
8:58valores que ya tienen los semáforos
9:00podemos este obviar el ipc exclusivo y
9:04si mandamos a crear y el conjunto será
9:08que quizá existe lo va a pisar sí
9:12bueno y después vienen los permisos que
9:14forman parte de
9:18forman parte de los flag del tercer
9:20argumento este 0 indica que lo que viene
9:24a continuación es un número tal
9:26el número total es este es el número
9:29total indica que el creador o sea el
9:32usuario que va a ejecutar este código
9:35para crear el conjunto va a tener
9:39permiso de lectura y escritura sobre los
9:42semáforos del conjunto eso lo indica el
9:456 si estos dos indican ausencia de
9:50permisos para los usuarios del grupo del
9:54creador y los otros usuarios bueno la
9:57cuestión es que el creador el usuario
10:00que ejecuta este código va a tener
10:02permiso de acceso de lectura/escritura
10:04sobre los semáforos bien acá vamos a
10:07preguntar entonces qué sucedió con el
10:09sen get
10:11el sjr no es igual
10:16existe entonces quiere decir que el
10:23conjunto
10:26ya existe
10:32junto
10:35semáforos para la clave
10:420 x a
10:48sí no
10:50entonces vamos a ver que tiene se mida
10:54adentro
10:55entonces se mide es igual a
11:03ahí está entonces mostramos lo que tiene
11:06esa mira adentro que debería ser un
11:08valor distinto a menos 1
11:10bueno ahí tenemos el código vamos a
11:13guardar lo vamos a cerrar
11:16vamos a compilar lo
11:21le vamos a poner crea al ejecutable
11:24bueno
11:28bueno fíjense que no tenemos ningún
11:30conjunto de semáforos creados vamos a
11:32ejecutar crea
11:35y ahí nos dice que se mide el
11:37identificador del conjunto que nos
11:40devuelve el sistema operativo es ese
11:43bueno y ahí tenemos entonces
11:47en la columna de aquí tenemos la clave
11:50un número extra decimal como máximo de
11:53ocho dígitos esa es la clave que le puso
11:56el programador en el código esto es lo
11:58que nos retorna el sistema el
12:00identificador del conjunto de semáforos
12:04el usuario que ejecutó el proceso de
12:07creación que se convierte en el dueño
12:08del conjunto de semáforos los permisos
12:11para el dueño si herrera los permisos
12:13para el dueño son estos
12:16y entonces el dueño va a tener el
12:18permiso de lectura y escritura sobre los
12:21semáforos del conjunto y acabamos de
12:24crear dos semáforos y es importante
12:28saber que para identificar el semáforo
12:32del conjunto lo vamos identificar por
12:35ejemplo 0 y el este se mide entonces
12:40tenemos el semáforo 0 del conjunto 58 98
12:4340 y tenemos el semáforo 1 del conjunto
12:4858 98 40 si ahora después vamos a ver
12:52como dentro del código podemos usar uno
12:55u otro semáforo
12:57bien y si mandamos a ejecutar de nuevo
13:00la creación entonces fíjense que nos
13:04dice ya existe un conjunto de semáforos
13:06para la clave se requisa otra cosa que
13:09podemos ver es cómo borrar de la línea
13:11de comandos
13:13un recurso semáforos entonces podemos
13:16usar el comando ipc
13:19rm y entonces acá le vamos a poner que
13:24queremos borrar un conjunto de semáforos
13:27y le pasamos el 58 98 40 así entonces el
13:34comando para borrar el recurso semáforo
13:36sería ips rm ese es el argumento
13:39semáforo y el jemad y del conjunto que
13:43queremos borrar ahí está si ahora
13:47miramos no tenemos nada si bueno lo
13:51creamos de nuevo lo creamos de nuevo
13:53ahora nos dio otro
13:56vamos a
13:58a ver ahí vemos
14:02los datos del conjunto la clave el nuevo
14:05y de los demás propietarios permisos y
14:07números semáforos es es igual y si
14:11mandamos a crear de nuevo nos dice que
14:14ella existe un conjunto de semáforos
14:16para la clave pero quizá bueno nos
14:19quedamos con nos quedamos con este
14:21conjunto sí que es el que vamos a usar
14:24en nuestro ejemplo bien
14:28bueno antes de seguir adelante tenemos
14:31que hacer un poquito de teoría para
14:33entender mejor lo que se viene así que
14:36vamos a hacer un poquito
14:41bueno no nos tenemos que olvidar que
14:43estamos trabajando en un sistema
14:44operativo
14:46con multiprogramación mono procesamiento
14:48y mousse de usuario fuertemente acoplado
14:50así que en estos entornos y más
14:54específicamente donde hay
14:55multiprogramación tenemos acceso
14:57concurrente a datos compartidos de
15:00distintos procesos entonces esa
15:03concurrencia a datos compartidos puede
15:07provocar inconsistencia de datos y eso
15:10hay que tenerlo muy en cuenta entonces
15:12necesitamos
15:14mecanismos para asegurar la ejecución
15:17ordenada de procesos cooperativos si
15:20recuerden un poquito el vídeo cuando
15:23hicimos trabajamos con el abecedario con
15:24un proceso padre y un proceso hijo que
15:27hicimos una suerte de sincronización con
15:29el sleep cosa que no se debe hacer
15:32ahora vamos a usar el mecanismo que si
15:35se usa para sincronizar que son los
15:38semáforos entonces
15:41lo que presenta la bibliografía es
15:43buscar soluciones para el problema del
15:45producto al consumidor donde el
15:48productor consumidor son dos procesos
15:49que acceden en forma concurrente
15:53al mismo segmento de memoria compartida
15:56la condición de concurso existe cuando
16:00hay acceso concurrente desde distintos
16:02procesos a datos compartidos y entonces
16:06el resultado final de las
16:08actualizaciones de esos datos
16:09compartidos depende del orden de
16:11ejecución de los procesos
16:14la sección crítica es una instrucción o
16:18un conjunto de instrucciones dentro del
16:20proceso donde esas instrucciones acceden
16:24a datos compartidos oa memoria
16:26compartida así entonces si nosotros
16:29tenemos dentro de un proceso una
16:32instrucción que accede a un recurso
16:35compartido bueno esa instrucción es una
16:38sección crítica
16:39puede ser más de una instrucción por
16:41supuesto toda sección crítica debería
16:44tener una sección de entrada que es la
16:46parte del código que evalúa la
16:49posibilidad de entrar
16:52a ejecutar de seguir ejecutando las
16:54instrucciones que acceden a los datos
16:57compartidos y la sección crítica también
17:00debería tener una sección de salida que
17:02son las instrucciones que se ejecutan
17:06para indicar que el proceso salió de su
17:09sección crítica
17:11bueno aquí vemos una estructura
17:13[Música]
17:15lo que podría ser la parte de código de
17:17un proceso productor o consumidor
17:20que accede tanto a producir oa consumir
17:23a datos compartidos y esas instrucciones
17:26por supuesto están dentro de la sección
17:28crítica a la sección crítica
17:31se le antepone una sección de entrada y
17:35después de la sección crítica se pone
17:37una sección de salidas y
17:39la sección de entrada deba evaluar si
17:42puede entrar el proceso a su sección
17:43crítica y la sección de salida va a
17:46indicar que el proceso sale de su
17:49sección crítica
17:52bueno aquí reemplazamos la sección de
17:55entrada por la operación de adquirir un
17:58cerrojo un candado si reemplazamos la
18:02sección de salida por la liberación del
18:04cerrojo o candado
18:07al adquirir el cerrojo lo pueden pensar
18:10como que sí
18:12veo una habitación con la puerta abierta
18:14entro y cierro la puerta y ya nadie
18:17puede entrar
18:19y la sección de salida la puedo lo
18:21pueden pensar como que salgo de la
18:23habitación y dejó la puerta abierta para
18:24que otra persona puede entrar sí
18:27viene el semáforo el semáforo sería
18:30nuestro cerrojo o candado
18:33básicamente es un área de memoria donde
18:35se almacena o se guarda un valor entero
18:39y asociados al semáforo tenemos dos
18:43operaciones era adquirir que evalúa y
18:46modifica el valor del semáforo y
18:50release o la liberación del semáforo
18:54modifica también el valor del semáforo
18:56así
18:58la operación adquirir también recibe el
19:01nombre de white o simplemente operación
19:03p lo que hace es testear el valor del
19:07semáforo mientras el valor sea mayor o
19:09igual a 0 punto y coma no hace nada
19:11y eso el proceso va a quedar evaluando
19:14el valor hasta que el valor cambie
19:16cuando el valor cambia el semáforo
19:19cuando el valor del semáforo cambia y
19:20vale 1 entonces sale del ciclo de
19:22evaluación
19:24le resta un semáforo quiere decir que lo
19:27deja en 0 nuevamente
19:29el proceso pasa a la sección crítica
19:31esto quiere decir que si el proceso está
19:33en la sección crítica el semáforo
19:34debería avalar 0
19:36y cuando el proceso sale de la sección
19:39crítica hace la liberación del semáforo
19:43o también llamado signal o simplemente
19:46operación b le suma 1 al semáforo quiere
19:50decir que cuando el proceso salió la
19:52sección crítica el semáforo vale 1
19:54básicamente
19:57mientras el proceso está en la sección
19:59crítica el semáforo vale 0 y cuando sale
20:03de la sección crítica el semáforo vale 1
20:06esto es una versión muy resumida del
20:09funcionamiento interno del semáforo
20:13y hablando por supuesto de semáforos que
20:16toman el valor 0 y 1 nada más en cómo
20:20decíamos hay semáforos que pueden tomar
20:22los valores 0 y 1 nada más esos son los
20:24semáforos binarios también llamados mu
20:27text pero también existen los semáforos
20:29contadores o semáforos de cuenta que
20:32pueden tomar cualquier valor entero si
20:34nosotros en este vídeo vamos a trabajar
20:37con los semáforos binarios esto ha sido
20:40una breve explicación teórica así que
20:43por favor nos recomiendo la lectura de
20:45la bibliografía con respecto al tema de
20:49sincronización
20:50bueno ahora podemos seguir adelante con
20:53una explicación
20:55la llamada de sistemas en control
20:59el zen control
21:04bueno con el mst l lo que puedo hacer
21:07por ejemplo es inicializar en los
21:10semáforos si el cen ctl me devuelve un
21:14entero si menos 1 caso de error
21:20si el pse telecom se ejecuta me devuelve
21:23menos 1
21:24el 100 7 le fracaso por algún motivo
21:27cuáles son los argumentos del ctl bien
21:30un entero
21:33que es el c maybin
21:36o sea tengo que pasar el identificador
21:40del conjunto de semáforos el segundo
21:43argumento quién es lo que pasará al mst
21:46l es el número del semáforo un entero
21:50que es el número del semáforo
21:54y bueno en nuestro caso nosotros creamos
21:57dos semáforos así que yo debería pasar
21:5910 o 11 que no es el valor del semáforo
22:04es el número de semáforos y
22:08quiero inicializar el semáforo cero voy
22:11a pasarlo un 0 si quiero inicializar el
22:13semáforo 1 le voy a pasar un 1
22:16bien el tercer argumento es un entero
22:21que es el comando si el cmd que es lo
22:25que quiero hacer en este caso le voy a
22:26pasar el comando set vale si set vale es
22:33el comando que voy a usar para aceptar
22:35el valor del semáforo
22:37y el cuarto argumento es un entero que
22:42es el valor
22:45inicial del semáforo o el valor que le
22:47quiero dar al semáforo
22:50que tratándose de un semáforo binario
23:00debería inicializar lo en el valor cero
23:03o en el valor 1
23:06si lo inicial hizo en el valor cero
23:08entonces quiere decir que la puerta está
23:10cerrada si el proceso cuando evalúe con
23:16la sección de entrada el semáforo lo va
23:18a encontrar en cero y no va a poder
23:20entrar a la sección crítica
23:22y si lo inicial hizo con el valor 1 el
23:25proceso que haga una adquirir un white o
23:28un p sobre el semáforo en la sección de
23:30entrada el valor del semáforo es 1
23:33entonces lo va a poner el 0 a
23:36decrementar y va a entrar a la sección
23:38crítica así bien bueno entonces nosotros
23:41vamos a usar el set el en este caso para
23:43inicializar los semáforos
23:48bueno ahora vamos a ejemplificar en un
23:50código el uso del sen control o sea 7 l
23:55para inicializar los semáforos que hemos
23:58creado sí
24:00ya copia que aparte del código las
24:03cabeceras son las mismas
24:05un pequeño o una pequeña aclaración
24:07fíjense
24:17bien fíjense cómo usamos el zinc y ahora
24:21esa forma de schengen es para obtener el
24:25cem haití de un conjunto de semáforos ya
24:28creados
24:29entonces si anulamos el segundo y el
24:33tercer argumento y el primer argumento
24:36es la clave de un conjunto es la clave
24:39del programador de un conjunto de
24:41semáforos que ya existe entonces en get
24:43lo único que hace es obtener el cem
24:45haití de ese conjunto
24:50bien vamos a preguntar ahora si se me da
24:55es distinto de -1
24:59si se mide distinto de menos 1 entonces
25:01vamos a inicializar los dos semáforos
25:06entonces
25:0867 l él se mide si el identificador del
25:13conjunto de semáforos el número del
25:15semáforo
25:17el primer semáforo del conjunto
25:21el comando set vall para inicializar lo
25:24y el valor de inicialización el 1 lo
25:29vamos inicializar en 1 al semáforo 0 del
25:32conjunto se emite lo vamos a inicializar
25:34en 1
25:39al semáforo 1
25:42del conjunto se mide lo vamos a
25:45inicializar en cero
25:49vamos a poner else
25:52efe
26:11bueno ahí estamos entonces vamos a
26:15guardarlo
26:17vamos a compilar lo
26:34y ni le vamos a poner ejecutables
26:39bueno ahora lo vamos a ejecutar
26:43la inicialización y bueno me da error
26:47del sen get porque creo que nosotros
26:50habíamos borrado el conjunto así que
26:52vamos a ver si existe el conjunto
26:57no no existe el conjunto de semáforos
27:00por eso el sen get falla
27:02entonces me devuelve menos 1 bien
27:06entonces ahora vamos a crear acuérdense
27:08que nosotros teníamos el programita crea
27:10ahí está ahí creó el conjunto de
27:15semáforos con otros emad y por supuesto
27:18y ahora lo inicializa mos
27:21ahí está bueno tenemos que confiar qué
27:26proceso init inicial hizo los semáforos
27:29como nosotros queríamos que los
27:31inicializar independientemente de ello
27:34podremos hacer un programita
27:38para ver el contenido del semáforo voy a
27:41copiar in its en a ver sem
27:44punto c
27:46entonces voy a editar versión y lo voy a
27:49modificar
27:51verse
27:54bueno entonces ahora vamos a usar el sem
27:577 l
27:58para ver el contenido del semáforo
28:02entonces el comando para ver el
28:04contenido de un semáforo el get by
28:08sí ahí está entonces ahora lo que
28:11hacemos es recuperamos el pse mighty del
28:16conjunto cuya clave de programadores
28:18héroe quizá si no falla el send get
28:21entonces usamos mtl para ver el
28:25contenido del semáforo que queremos ver
28:27en este caso es del conjunto se mide el
28:32valor del semáforo 0 y del conjunto se
28:36mide el valor del semáforo 1 para ello
28:40lo que tenemos que hacer es meter el sem
28:43ctl dentro de un print
28:46efe para verlo
28:49brin efe
28:51bueno ya que podemos poner
28:5660
29:04y ahí vamos a ver el valor
29:08son los mismos
29:16vamos a ver ahora el valor del semáforo
29:191
29:22y acá le ponemos el paréntesis bueno ahí
29:26estaría entonces vamos a ver si funciona
29:29entonces mostramos con el print efe el
29:33valor que tiene el semáforo 0 y
29:35mostramos con el print efe el valor que
29:38tiene el semáforo 1 siempre hablando del
29:41conjunto de semáforos se mide
29:44guardamos vamos a compilar
29:48a este le vamos a poner ver
29:55acá vamos a poner ver
29:58vamos a poner
30:00bueno listo vamos a ejecutarlo
30:04y efectivamente vemos que el valor del
30:06semáforo 0 es la inicialización 1 y el
30:09valor del semáforo 1 es la
30:11inicialización 0 bien
30:14bien recién en la breve explicación
30:16teórica dijimos que había dos
30:18operaciones una operación era adquirir
30:23y la otra liberar o weight y la otra
30:26signal o pe y la otra operación be bueno
30:31hay que hacer un pequeño código para
30:32poder ejecutar esas operaciones así que
30:35lo que vamos a hacer ahora es escribir
30:37ese código
30:39bien vamos a escribir dos funciones
30:43a uno le voy a llamar p
30:52y le vamos a pasar a esa función dos
30:54enteros sí
30:55el primero entero es el identificador
30:58del conjunto de semáforos y el segundo
31:00entero es el número del semáforo si
31:03vamos a definir una estructura
31:07que llamasen buff
31:10y vamos a crear una instancia de esa
31:12estructura llamada buff
31:15y ahora vamos a cargar esa estructura
31:20la primera parte de la estructura el
31:22primer atributo la estructura es el
31:24número del semáforo que viene a la
31:25función que entra la función p en el
31:28segundo argumento ese es el número del
31:30semáforo
31:33y después vamos a cargar en el segundo
31:36atributo de la estructura
31:39la operación
31:41este número menos 1 define la operación
31:45p o define la operación white o define
31:49la operación adquirir si las tres las
31:53nombramos de la misma manera nombramos
31:55distintas pero significa la misma
31:56operación y el último atributo que vamos
32:03a inicializar son los flag bueno después
32:06podríamos hablar mucho de los flags por
32:09ahora vamos a hacer la operación más
32:10simple este estándar de la operación p
32:14o adquirir sí bueno pero eso no mandó a
32:18ejecutar el adquirir sino cuando
32:21ejecutar la operación pero que va mandó
32:22a ejecutar la operación p es el sem o la
32:25llamada al sistema se move sí que es la
32:28última en este vídeo que vamos a
32:31presentar entonces cuáles son los
32:33argumentos de se move
32:36bueno se mide sobre qué cuál es el array
32:41que contiene al semáforo sobre el cual
32:43se va a realizar la operación
32:46la operación que está definida en la
32:49estructura voz y cuántas operaciones son
32:53entonces se move cuando se ejecute ese
32:56move
32:58con esta configuración
33:01para este semáforo se va a ejecutar el
33:05adquirir entonces se va a ejecutar el
33:08adquirir aquí para que semáforo para
33:12este semáforo de que conjunto de este
33:16conjunto
33:18bien y de la misma forma que definimos
33:20la operación
33:24adquirir
33:26podemos definir la operación liberar o
33:30signal v
33:32si luego de cambiar ese es el nombre de
33:34la función y la operación ahora la
33:38operación es 1 básicamente lo que hace
33:44este lo que va a ser la ejecución de ese
33:47move eleva va a evaluar va a evaluar el
33:50semáforo para evaluar el semáforo y le
33:53va a restar 1 si el semáforo tiene un
33:57valor mayor a 0
34:01y esta operación directamente le va a
34:04sumar 1 entonces en la explicación en la
34:07breve explicación teórica de que dijimos
34:09que pedimos
34:11la operación p evaluaba el semáforo y si
34:15el semáforo tenía un valor mayor que 0
34:18entonces le restaba 1 y el proceso
34:21seguía la sección crítica y el semáforo
34:22quedaba en 0 y la operación b
34:26o liberar lo que así era sumarle uno sí
34:29bueno ya hemos definido
34:31en las dos operaciones la operación que
34:35se va a ejecutar acá y la operación se
34:38va a encontrar acá
34:40bueno no vamos a hacer mine a este punto
34:43se lo vamos a guardar así
34:46lo vamos a guardar así como vamos a
34:49compilar un
34:50punto sé que no tiene main vamos a
34:53compilar así cc
34:58p
35:01p
35:13bien
35:17del punto c
35:22bueno esto lo que obtiene es un programa
35:26de objeto
35:33ahí está
35:36si entonces yo escribo un punto ce en
35:39este caso por ejemplo que no tiene main
35:41no puede ser ejecutable pero sí puede
35:44ser un programa objeto la línea de
35:46compilación para crear un programa
35:47objeto es esta si bueno ese es nuestro
35:51primer paso bueno ahora tenemos que
35:54poner a prueba lo que hicimos si
35:57entonces la idea es hacer un pequeño
35:59ejercicio un ejercicio muy simple para
36:03lograr una ejecución ordenada entre un
36:07proceso y un proceso ve si suponemos que
36:12los dos procesos están en un ciclo
36:14infinito de producción con su misión del
36:16proceso a produce y el proceso que
36:18consume
36:20entonces el orden de ingreso a la
36:22sección crítica debería ser el siguiente
36:26primero pea produce bebe consume sea
36:31produce bebé consume sea produce tv
36:35consume y así se quedan infinitamente
36:38ese es el orden productor consumidor
36:41productor consumidor productor
36:43consumidor si en un ciclo infinito bueno
36:47para ello hemos creado dos semáforos el
36:50semáforo 0 y el semáforo 1 e inicial
36:55izamos el semáforo 0 en 1 y el semáforo
36:581 en 0
37:00entonces
37:02el proceso a
37:04en su ciclo infinito
37:07tiene una sección crítica que es la de
37:09producción del proceso ah pero debería
37:13tener una sección de entrada y una
37:15sección de salida
37:17y el proceso ve también en un ciclo
37:22infinito tiene su sección crítica con su
37:26misión del proceso ve y debería tener
37:28esa sección crítica una sección de
37:31entrada y una sección de salida
37:34cuál es la sección de entrada del
37:36proceso a es evaluar
37:40o sea la operación adquirir evaluar
37:45del conjunto se mide el semáforo 0
37:50cuál es la sección de entrada a la
37:54sección crítica del proceso de evaluar
37:57de la raíz de 1000
38:00el proceso el semáforo 1 pues la sección
38:05de salida del proceso a
38:08liberar
38:10de la rai o de conjunto se mide el
38:14semáforo 1 y cuál es la sección de
38:17salida del proceso b
38:21es liberar
38:23del arraigo del conjunto
38:27de semáforo se mide el semáforo 0
38:32bien qué pasa si yo mando ejecutar el
38:35proceso antes que mandar ejecutar el
38:38proceso a entonces el proceso ve antes
38:42de entrar a la sección crítica va a
38:44evaluar el semáforo 1 entonces va a
38:47decir el valor del semáforo 1 es menor o
38:50igual a 0 le va a decir que sí entonces
38:54se va a bloquear en esa en esa sección
38:58de entrada sí y ahí va a quedar hasta
39:01cuándo y hasta que el semáforo 1 no
39:05cambia su valor de 0 a 1 entonces yo voy
39:07a mandar a ejecutar el proceso a el
39:10proceso a entonces va a evaluar el
39:14semáforo 0 va a decir el valor del
39:16semáforo 0 es menor o igual a 0 le va a
39:20decir que no por qué porque lo
39:22inicializa mohsén 1 entonces qué va a
39:24ser le va a restar 1 al semáforo 0 le va
39:28a restar 1 lo va a dejar en 0
39:31y va a entrar la sección crítica cuando
39:34se haga la sección crítica que va a ser
39:36va a señalizar olivera del semáforo 1
39:39qué quiere decir eso que le va a sumar 1
39:42el semáforo 1 entonces el estado
39:46nuestros semáforos ahora es 0 para él se
39:48mostró 0 y 1 por el semáforo 1 qué
39:51quiere decir que cuando vuelva el
39:54proceso a evaluar el semáforo 0 lo va a
39:56encontrar el servicio al quedar
39:58bloqueado acá pero sin embargo el
40:01proceso a cambio el valor del semáforo 1
40:04entonces el proceso ve ahora va a
40:07encontrar un semáforo 1 en 1 que va a
40:10suceder y va puede pasar a la sección
40:13crítica porque su valor del semáforo es
40:161 pero antes de entrar va a dejar el
40:19semáforo 1 en 0 entra a la sección
40:22crítica
40:23cuando sale de la sección crítica
40:26calibrar el semáforo 0 entonces el
40:29semáforo 0 pasa valor 1 entonces en esto
40:34en este estado ahora el que puede entrar
40:36sección crítica es a y el que no puede
40:39entrar es bueno
40:42esto va a suceder infinitamente con esto
40:45con esta inicialización del semáforo 0
40:48en 1 y del semáforo no el 0 lo que vamos
40:51a lograr una sincronización de ejecución
40:55de ingreso a la sección crítica en el
40:58orden proceso a proceso de proceso a
41:01proceso de proceso a proceso de bueno
41:06van a quedar en el ciclo sí
41:09infinitamente bueno de ahora vamos a
41:13pasar esto a código sí
41:20bien ya tengo el proceso ha escrito para
41:23ahorrar tiempo porque se está haciendo
41:25muy largo el vídeo
41:27entonces acá tenemos el proceso
41:31el proceso a bueno todas las cabeceras
41:33que tiene que tener tiene los prototipos
41:37que están en el objeto p y ve acá están
41:44los prototipos de las funciones adquirir
41:46y liberar
41:48después tenemos acá el main del proceso
41:51a que necesita por supuesto saber el
41:55identificador del conjunto de semáforos
41:57y este es el ciclo infinito de
42:00producción simulando una producción no
42:02estamos produciendo nada en este vídeo
42:07simulando la producción en este ciclo
42:09infinito del proceso entonces simulamos
42:13acá la sección crítica y simulamos la
42:16sección crítica la sección crítica ahí
42:19debería haber un acceso a datos
42:21compartidos un acceso
42:23una memoria compartida pero simplemente
42:27para este vídeo tenemos el print y el
42:29slip el slip acá no cumple ninguna
42:31función de sincronización simplemente un
42:33retardo de ejecución en la producción
42:35nada más acá la sincronización está dada
42:38por los semáforos este 0 y por el
42:40semáforo 1 nada más
42:43la sección de entrada entonces es el
42:46adquirir el semáforo 0 y la sección de
42:49salida es liberar el semáforo 1 como
42:52explicamos este es el proceso el proceso
42:57y el proceso b
43:02a diferencia del proceso a simula ser el
43:06consumidor
43:08acá tienen los prototipos del
43:10adquirirlos el prototipo de liberar a
43:14semáforo por supuesto también tiene que
43:16conocer el y del conjunto de semáforos
43:19la sección crítica simulada de
43:23consumición no hay acceso en este caso a
43:25memoria compartida
43:29y el slip es para darle un retardo en la
43:31pantalla y ver el funcionamiento pero no
43:34tiene nada que ver con la sincronización
43:36repito la sincronización está dada por
43:38los semáforos pero yo no en este caso el
43:40proceso ve hace un alivio del semáforo 1
43:43y un liberar del semáforo 0 exactamente
43:46al revés que el proceso a sí bueno
43:56ahora les voy a mostrar un pequeño
43:59script
43:59que tenemos para poder compilar todo así
44:06me puse con pilar
44:10bien esta es la línea de comandos para
44:13obtener el programa objeto de pib punto
44:17c esta es la línea de comando para
44:20obtener el programa objeto de p a punto
44:24c y está la línea de comando para
44:26obtener el programa objeto de bebé
44:30ahí está
44:33eso es público pipas
44:36bien acá en la línea 5 tenemos la línea
44:41de comando para digamos obtener un
44:45ejecutable
44:47del objeto pib y el objeto vea o sea que
44:54los dos objetos me van a generar
44:57el ejecutable vea y esta es la línea
45:01para obtener el ejecutable pp también
45:05desde el objeto pib punto y el objeto pp
45:10punto entonces vamos a tener dos
45:12ejecutables con acceso a las funciones
45:16pib
45:18ahí está bueno vamos a
45:23ejecutar el compilar
45:29bien y ahí obtuvimos el ejecutable pea
45:34y el ejecutable pv lo único que tenemos
45:38que hacer ahora es probarlo
45:40y pp
45:42no son procesos emparentados a través de
45:45un fork así que son procesos
45:47independientes podemos ejecutarlo en dos
45:51terminales distintas entonces voy a
45:54abrir otra terminal
45:57esta va a ser una terminal
46:04y aquí vamos a tener otra terminal
46:24en una terminal vamos a ejecutar el
46:28proceso y en la otra vamos ejecutar el
46:31proceso
46:32vamos a ver la inicialización de los
46:35semáforos para recordar un poquito
46:37ahí está el semáforo 0 esta inicial
46:40izado en 1 la puerta para entrar la
46:42sección crítica está abierta para el
46:44proceso a y el semáforo 1 esta inicial
46:47izado en 0 la puerta está cerrada para
46:49entrar a la sección crítica en el
46:51proceso b o sea que lo único que puede
46:53entrar sección crítica es
46:56él ve no va a poder hasta que la
46:59habilite su semáforo así que bueno vamos
47:02a limpiar la pantalla y vamos a ejecutar
47:04de este lado el proceso a todavía no lo
47:08vamos a ejecutar vamos a mandar ejecutar
47:10primero el proceso ve para que se
47:13perciba el bloqueo si mandó ejecutar al
47:17proceso
47:17ven ahí está el proceso ve se quedó
47:21bloqueado en la sección de entrada p se
47:26me toma 1
47:28ahora cuando mande ejecutar el proceso y
47:33entonces va a empezar el ciclo de
47:35producción con su misión simulado
47:37ahí está proceso a proceso de a&b
47:42bueno así se realizan las
47:45sincronizaciones con semáforos y bueno
47:53y ahí los dejamos ejecutando
47:56infinitamente
47:58bueno espero que este vídeo les sirva
48:00les ayude a entender el uso y algunos
48:04conceptos básicos de semáforos aquí les
48:06dejo en esta imagen
48:09los dos vídeos que deberían ver ahora y
48:12que creo que pueden entender con mayor
48:16facilidad sincronización vaca y
48:18semáforos por si nombra 201 esos son los
48:22vídeos que deberían ver ahora bueno
48:24hasta el próximo vídeo
48:28[Música]

About this transcript

This page contains the full transcript of C Linux Semáforos System V 01 by juancarlosjromer, generated from the public captions YouTube serves with the video. The transcript has 5,748 words across 929 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.