Protocolos de Comunicaciones

Summary

El script proporciona una descripción detallada sobre la creación de protocolos de comunicación entre módulos en un entorno de programación. Se discute la serialización de mensajes, la importancia de la comprensión del tamaño de los datos y cómo enviar y recibir paquetes de información entre el kernel y la memoria. Se destaca la necesidad de funciones genéricas para agregar y extraer diferentes tipos de datos a un buffer, como enteros, cadenas de caracteres y otros tipos de mensajes, y se abordan técnicas para manejar la memoria dinámicamente. Además, se menciona la importancia del código de operación para la serialización y deserialización de paquetes, asegurando que los datos se envíen y se reciban en el orden correcto. El video finaliza con una demostración de la aplicación de estos conceptos en la creación de una consola interactiva, destacando la interacción entre procesos y la gestión de prioridades.

Takeaways

• 📝 Se discute la creación de protocolos para el envío de mensajes entre módulos en un sistema operativo.
• 🔌 Se menciona la importancia de la serialización de mensajes y se hace referencia a una guía de serialización para evitar errores.
• 💾 Se explica el proceso de envío de un mensaje desde un módulo, como el kernel, hacia la memoria, utilizando una función de envío de paquete.
• 🔗 Se destaca la recepción de mensajes en la memoria, donde un bucle `while` espera y bloquea hasta recibir algo a través de un socket.
• 📦 Se describe la estructura de los mensajes, que incluyen un código de operación, tamaño y el propio contenido del mensaje (payload).
• ⚙️ Se detalla cómo se genera y maneja un buffer (`wofer`) que contiene información serializada para su envío y recepción.
• 🔄 Se nombra la función `receive` como clave para extraer la información del buffer y convertirla en una estructura de datos utilizable.
• 📚 Se sugiere la creación de funciones genéricas para agregar y extraer diferentes tipos de datos al buffer, como enteros (`int`), cadenas de caracteres (`char asterisco`) y otros.
• 🧩 Se habla sobre el manejo de memoria dinámica, incluyendo la reserva y liberación de memoria para almacenar temporalmente los datos extraídos.
• 🛠️ Se abordan técnicas de álgebra de punteros para manipular la dirección de memoria y el desplazamiento de datos durante la serialización y deserialización.
• ➡️ Se ilustra el proceso de serialización de un paquete, que implica agregar información adicional al comienzo del buffer para facilitar la deserialización en el destinatario.

Q & A

¿Qué es lo que se discute en el video sobre la creación de protocolos de envío de mensajes?

El video trata sobre la creación de protocolos para enviar mensajes entre módulos. Se menciona la importancia de la serialización y cómo se puede implementar la comunicación entre diferentes partes del sistema.

¿Por qué es importante la serialización en el contexto del video?

La serialización es crucial para convertir datos estructurados en una secuencia de bytes que puedan ser transmitidos a través de una conexión. Esto permite que los datos sean enviados y recibidos de manera coherente entre módulos.

¿Qué es un 'wofer' en el contexto del video?

Un 'wofer' es una estructura utilizada en el video para representar un paquete de datos que incluye información como el tamaño (size) y el flujo de bytes (stream). Es un componente clave en la serialización y deserialización de mensajes.

¿Cómo se describe el proceso de envío de un mensaje desde el kernel a la memoria en el video?

El proceso comienza con la generación de un 'wofer' que contiene el mensaje a enviar. Luego, se utiliza una función de envío de paquete que incluye el 'wofer', la conexión de socket y el tamaño del mensaje. El mensaje se envía a través de esta conexión y espera ser recibido por la memoria.

¿Qué contiene el 'choclo' que se menciona en el video?

El 'choclo' es una representación del mensaje que se envía y contiene tres partes generales: el código de operación, el tamaño de este código y el buffer de datos real. Este buffer puede contener diferentes tipos de datos, como enteros, cadenas de caracteres u otros bloques de datos.

¿Cómo se espera que la memoria maneje la recepción de un mensaje?

La memoria espera recibir el mensaje a través de un socket, utilizando una función 'receive' que incluye un 'receive' bloqueante para esperar hasta que se reciba algo. Una vez que se recibe un mensaje, se extrae el código de operación y se almacena en la memoria.

¿Qué es el 'código de operación' y cómo se utiliza en la comunicación entre módulos?

El 'código de operación' es una parte del 'choclo' que indica el tipo de operación que se está realizando. Se utiliza para que el receptor del mensaje sepa cómo interpretar y procesar los datos que le siguen.

¿Cómo se describe la función 'crear super paquete' en el video?

La función 'crear super paquete' se utiliza para crear un paquete que incluye un código de operación y un 'wofer'. Este paquete es más grande y contiene toda la información necesaria para que el receptor sepa cómo manejar el mensaje.

¿Qué es la consola interactiva que se menciona en el video?

La consola interactiva es una parte del sistema que permite a los usuarios interactuar con el kernel. En el video se muestra cómo se puede utilizar para enviar información, como el ID de proceso y la prioridad, al kernel.

¿Cómo se aborda el tema de la prioridad en el video?

La prioridad se menciona en el contexto de la administración de procesos por parte del kernel. Aunque se puede establecer una prioridad para los procesos, se indica que esta información no se envía a la memoria, sino que es utilizada internamente por el kernel.

¿Qué se espera que el espectador haya comprendido al final del video?

Se espera que el espectador haya comprendido el proceso de serialización y deserialización de mensajes, la importancia de la estructura 'wofer' y cómo se envían y reciben mensajes entre módulos. Además, se espera que comprenda cómo se utiliza la consola interactiva para enviar información al kernel.

Outlines

00:00

😀 Creación de protocolos de mensajería entre módulos

Se discute la creación de protocolos para enviar mensajes entre módulos, haciendo referencia a la importancia de la serialización y cómo se maneja la información en el kernel. Se menciona la utilización de funciones como 'enviar paquete' y se destaca la necesidad de estudiar la guía de serialización para evitar errores.

05:01

🔌 Proceso de recepción de mensajes en la memoria

Se explica cómo la memoria espera y recibe mensajes del kernel utilizando un receive bloqueante. Se describe el proceso de extracción de información, incluyendo el código de operación y el tamaño de los datos transmitidos. Además, se menciona la creación de estructuras para manejar diferentes tipos de mensajes según el código de operación recibido.

10:03

📦 Creación y recepción de un 'woof' en memoria

Se detalla cómo se crea una variable 't woofer' para recibir y almacenar información, y cómo se utiliza una función genérica para extraer el resto de la información de un 'woof'. Se abordan los conceptos de recepción de todo el buffer del mensaje y la importancia de manejar estructuras de datos adecuadamente.

15:04

📚 Contenido y manipulación del 'woof' en memoria

Se explora qué contiene el 'woof', que es una estructura de datos que puede incluir diferentes tipos de información, como enteros, cadenas de caracteres y otros bloques de datos. Se discute cómo se agregan y manipulan estos elementos dentro del 'woof', y cómo se impacta en el tamaño del stream de bytes.

20:07

🔄 Proceso de almacenamiento y extracción de información

Se describe el proceso de almacenamiento de información en un buffer y la creación de funciones para agregar y extraer información de dicho buffer. Se abordan técnicas como la 'álgebra de punteros' para manipular eficientemente la memoria y los datos almacenados.

25:09

🛠️ Funcionalidades para manejar buffers y streams

Se detallan las funcionalidades creadas para agregar y extraer información de un buffer, incluyendo la gestión de memoria dinámica y la creación de funciones genéricas para diferentes tipos de datos. Se destaca la importancia de liberar la memoria reservada una vez que se haya utilizado la información extraída.

30:13

🔗 Proceso de serialización de paquetes de mensajería

Se explica el proceso de serialización de paquetes, que implica agregar información adicional al mensaje para que el receptor pueda interpretarlo correctamente. Se discute la adición del código de operación y el tamaño del mensaje antes de enviarlo, y cómo el receptor utiliza esta información para extraer y manejar el contenido del mensaje.

35:16

📝 Pruebas de funcionamiento del sistema de mensajería

Se narran los pasos para probar el sistema de mensajería, incluyendo la creación de procesos y la ejecución de comandos en la consola interactiva. Se menciona el envío de información como PID y prioridad, y se destaca cómo la memoria recibe y maneja estos datos.

40:20

📈 Resumen y expectativas para la siguiente parte

Se ofrece un resumen de los conceptos y funcionalidades discutidos hasta el momento y se establecen expectativas para la siguiente parte del video, que se enfocará en la consola. Se cierra el párrafo con un adiós y una promesa de continuar la explicación en el próximo video.

Keywords

💡serialización

La serialización es el proceso de convertir una estructura de datos en una secuencia de bytes que puede ser enviada a través de una red o almacenada en un archivo. En el video, se discute cómo la serialización es fundamental para enviar mensajes entre módulos diferentes como 'kernel' y 'memoria'. Se menciona la importancia de saber cómo serializar datos correctamente para asegurar que el mensaje enviado sea recibido e interpretado adecuadamente en el otro extremo.

💡buffer

Un buffer en informática es un espacio de memoria en el que se almacenan temporalmente datos mientras son transferidos de un lugar a otro. En el video, se habla de cómo gestionar buffers para el envío de datos entre módulos, y se utiliza el término 'wofer' como una estructura que incluye tanto el tamaño del buffer como los datos mismos.

💡choclo

El término 'choclo' se usa en el video de manera informal para referirse a un conjunto o agrupación de datos que se manejan juntos. Este término se usa para explicar cómo se estructuran los datos antes de enviarlos a través de un socket, implicando una mezcla de varios tipos de datos como enteros, cadenas, etc., que están serializados juntos.

💡socket

Un socket es un punto final de un flujo de comunicación bidireccional entre dos programas que corren en la red. En el video, se habla de enviar un 'void asterisco' a través de un socket para la comunicación entre 'kernel' y 'memoria', destacando cómo se utiliza para transferir datos serializados.

💡memoria

En el contexto del video, 'memoria' parece referirse a un módulo o componente del sistema que recibe datos del 'kernel'. Se describe el proceso de cómo 'memoria' espera y recibe datos serializados, mostrando la importancia de tener un manejo adecuado de la recepción y procesamiento de datos en sistemas distribuidos.

💡reive

Reive parece ser una variación o error de transcripción de 'recv', una función en programación de sockets para recibir datos. En el video, se menciona cómo esta función bloquea el proceso esperando datos, lo que es crucial para entender cómo 'memoria' maneja la entrada de datos del 'kernel'.

💡función genérica

Una función genérica es una función diseñada para operar con diferentes tipos de datos. En el video, se describe cómo crear funciones genéricas para manipular los buffers, permitiendo agregar y extraer diferentes tipos de datos (int, char, etc.) de una forma modular y reutilizable.

💡operación

En el video, 'operación' se refiere a las acciones o tareas específicas que se realizan sobre los datos dentro del buffer. Se menciona una estructura de código de operación que ayuda a determinar cómo se debe tratar el mensaje recibido, lo que es esencial para el manejo correcto de los datos.

💡size

El término 'size' se refiere a la cantidad de espacio en bytes que ocupa un dato o conjunto de datos. Es crucial en la gestión de la memoria para saber cuánto espacio reservar y cómo interpretar los bytes recibidos. En el video, 'size' se utiliza para manejar adecuadamente la memoria al crear buffers y procesar datos recibidos.

💡estructura de datos

Una estructura de datos es una manera de organizar, administrar y almacenar datos de manera que sea fácil de acceder y modificar. En el video, se hace énfasis en cómo las estructuras de datos, como los buffers con sus respectivos 'sizes' y datos, son esenciales para la transmisión eficiente de información entre diferentes partes de un sistema.

Highlights

Se discute la creación de protocolos para el envío de mensajes entre módulos.

Se menciona la importancia de la serialización y se hace referencia a una guía de serialización.

Se explica paso a paso cómo serializar para evitar errores y se ofrece código de ejemplo.

Se describe el proceso de envío de un mensaje desde el módulo 'kernel' a 'memoria'.

Se detalla cómo se genera un 'void asterisco' utilizando una función de envío de paquete.

Se discute la recepción de mensajes en la memoria y cómo se espera la información enviada por el kernel.

Se destaca la estructura de los mensajes en tres partes generales y se mencionan subpartes adicionales.

Se describe el proceso de extracción del código de operación y su importancia para el manejo de diferentes tipos de mensajes.

Se explica cómo se almacenan y se accede a diferentes tipos de datos en el 'void asterisco'.

Se discute la creación de funcionalidades para agregar y extraer información de un 'wofer'.

Se abordan técnicas para manejar la memoria dinámica y evitar pérdidas de memoria.

Se describe el proceso de recepción de un mensaje completo y cómo se espera que el kernel envíe información adicional.

Se detallan las funciones genéricas para agregar y extraer información de un buffer.

Se discute la serialización de paquetes y su importancia para el intercambio de información entre módulos.

Se muestra cómo se crea un 'super paquete' utilizando el código de operación y se envía a la memoria.

Se ilustra el proceso de extracción de información de un buffer recibido por la memoria.

Se describe el uso de la consola interactiva y cómo se envían y reciben mensajes.

Se menciona que en una próxima clase se explicarán servicios de kernel y se dará más contexto sobre la consola.

Transcripts

bien Bueno ahora toca el video de crear

las funcionalidades de share para enviar

mensajes entre módulos y probar el envío

de mensajes entre módulos Bueno hoy

vamos a crear esos protocolos estos

protocolos de envío de mensajes Sí ahora

antes de continuar explicando eso hay

que mencionar que esa información de

serialización y de envío de mensajes

primeros

pasos

estaba a ver si me acuerdo en chiscar de

Lino guía de serialización aquí está hay

que verse todao esta

charla donde eh te explica sobre cómo

serializar está también ahí las

explicación ahí en texto por si queres

eh explicado paso por paso como para que

no haya errores y bueno un montón de

código de ejemplo como para que aprendas

a serializar sí es necesario que lo

mires lo estudies lo vivas Bueno lo

mismo en fin bueno

básicamente cómo vamos a hacer por

ejemplo ahora para en el ejemplo que

vamos a ocupar ahora carnel va a enviar

un mensaje a memoria Imagínate que esta

cosa todo este coso shif p era Sí todo

este coso es un Boy asterisco

un void asterisco Sí todo esto es un

void asterisco todo absolutamente todo y

eso vamos a llamar enviar un voy

asterisco al socket memoria en dónde

está eso pues aquí hay una función de

enviar paquete enviar paquete Bueno ya

Les explico que es esto de paquete pero

básicamente es generamos un voy

asterisco como aquí lo pueden ver que se

llama enviar y lo enviamos enviamos ese

voy asterisco con la conexión que le

ponemos Por ejemplo si estamos enviar

desde kernel el módulo consola c ya eh

Ya vamos a explicar el módulo consola

pun c en el próximo video pero aprovecho

que ya lo he creado para explicarles eso

desde consola c eh Le pongo el el socket

de memoria F descripto de memoria la

conexión con memoria que ya creamos al

inicio y lo enviamos y lo que hace esa

función es generar utilizando este

paquete genera un Buy asterisco o sea

genera todo todo este

choclo todo ese choclo y eh Lo envía con

la conexión que le pasamos en este caso

F el escripto de memoria lo enviamos

Este es el tamaño de la cosa que se

envía y bueno y nada Eso es básicamente

en enviar con ese Send que enviar

paquete esa funcionalidad que tenemos es

lo que hace es enviar un choclo a

memoria correcto bien Eso es

todo

ponele eso es la esencia básica y ahora

Qué contiene ese choclo como puedes ver

ese choclo contiene tres partes

generales porque en realidad esto

contiene más subpartes que ya vamos a

explicar e más adelante pero de en

líneas generales tiene tres partes el el

primero ya vamos a explicar cómo es que

kernel lo arma este choclo pero quiero

que sepas cómo es que memoria lo recibe

para que vayas haciendo ti una idea Por

ejemplo antes me antes de que kernel

genere este choclo para enviárselo sí

antes de que lo genere vamos a dejarlo

por arriba aquí memoria cómo está

memoria memoria vamos a memoria c

obviamente en memoria

source memoria c en la parte donde se

quede escuchando a

kernel eh memoria kernel acá si te das

cuenta

eh okay se queda en un While casi

infinito y aquí en recibir operación

recibir operación que es de nuestra

sharet contiene esa cosa que consiste en

reive Ese reive es clave porque ese

reive se queda o sea este igual en lugar

de ciclar continuamente se queda aquí en

esta en este en esta línea porque esta

función contiene un reive y el reive lo

lo bloquea aquí si se queda tildado

hasta línea esperando en recibir algo

por ese socket este socket esta conexión

en este caso Sí o sea se queda aquí se

queda en esta línea y se queda esperando

ese

reive bueno y se queda esperando aquí en

su receive memoria en ese hilo está

esperando que kern le envíe algo y se

queda tildado en esa línea Ah no avanza

más ese Wi se queda ahí bien teniendo en

mente eso cuando

kernel

apenas envía genera un choclo todo este

es un voy asterisco envía ese choclo y

le llega a

memoria entonces

lo primero que hace ese reive

literalmente al detectar que hay bits lo

primero que extrae es reive aparece te

aparece el socket de donde quieres

recibir

el wofer o sea Don dónde lo quieres

almacenar y el tamaño de esa cosa que

quieras almacenar por ejemplo está

extrayendo el código de operación y el

tamaño de ese código de operación es un

size of in o sea está ext no extrae si

te das cuenta no está recibiendo el todo

el buffer todo este voy asterisco

asqueroso no no no porque no sabe Cuánto

cuánto cuántos byes tiene encima así que

Pero lo que sí sabe es

eh shift p lo que sí sabe Es que este

código de

operación es un size of int size

of int Ahí va es un size of

int Qué significa eso Acá está Qué es el

tamaño de un in no extrae ese código de

operación y para qué extrae ese código

de

operación básicamente extrae esta parte

y para qué extrae esa parte porque

después que lo

extrae con ese código de operación según

el código de operación que nos nosotros

tengamos porque tenemos acá una

estructura de operación code

eh según estos estas estos de acá o las

las demás que agreguemos en el

futuro podemos tratar ese mensaje de

alguna forma u otra sí podemos tratarlo

eh ponerle que algunos mensajes ponerle

que este algunos mensajes van a tener

solo números int int in in van a tener

int int in int otros mensajes pueden

tener

int pueden tener un 32 un 32 y pueden

tener al final un char asterisco acá sí

pueden O sea hay distintos tipos de

mensaje y según este código de operación

Vamos a ingresar este switch Case y

vamos a tratarlo de una forma u otra en

este caso esto o esto o esto no Para eso

es el switch Case bien bueno el tema es

que este primer

código de operación lo que hace es

recibir operación y ese recibir

operación contiene un reive que es

bloqueante o sea hasta que no reciba

nada no se mueve de ahí una vez que

recibe algo lo primero que extrae es un

es un

int si extrae 4 by ponerle creo que se

son 4 by y lo almacena y lo retorna ese

código de operación y lo retorna

aquí Bueno hasta

ahí nosotros entonces sabemos que si ya

extrajimos esta parte esta parte ya está

extraída significa que

nuestro vamos a ver si me deja

nuestro coso ya se redujo

ahora lo que tenemos que esto ya está

esto ya está utilizado

esto Esta parte de acá ya fue utilizada

con el código de operación Ahora nos

falta recibir lo demás bien

eh y lo siguiente que tenemos que

recibir es a lo que hemos

Eh bueno esa funcionalidad nos falta

crear recibir todo el buffer del mensaje

por eso es que aquí le puse ya está

creada ahora Les explico recibir todo el

buffer del mensaje y lo que hace es

obviamente terminar de extraer este size

y todo este choclo Sí este size

obviamente es un int también

eh contiene la información de la

cantidad de bytes que que que pesa ese

ese Boy asterisco que le sigue no por

ejemplo esto puede decir 12 bytes este

puede entonces todo este choclo eh pesa

12 bytes Si nos dice que es 28 by

entonces todo este choclo pesa 28 by Sí

bueno Y dónde almacenamos esto bueno

tenemos estructuras del tp0 estructuras

como estas t woofer y ya te imaginarás

la funcionalidad que vamos a crear para

extraer el resto

de de cosas

va va a consistir en crear una variable

tipo t woofer extraer este size de aquí

y ubicarlo aquí luego según la

información que nos haya dado ses

tomar el resto de lo que falta ese voy

asterisco y ponerlo aquí que también

tenemos un voy asterisco ahí y listo y

luego vamos a trabajar con esa

estructura porque ya lo recibimos acá

vamos a tener nuestro

t ponele Ahí vamos a tener nuestro t

woofer eh un wofer ponele

sí eh vamos a

poner así tenemos tofer un

wofer y ese wofer va a

tener ponerle dos cosas no es

cierto ese va a tener dos cosas va a

tener el

si que es

este y va

tenery asterisco va

ser es asterisco y vamos a trabajar con

ese buer de acuerdo

Bueno ya tengo creada esa funcionalidad

Claro que sí se llama

recibir bueno acá está recibir todo del

buer Y contiene esos reive Porque así es

como

recibo extraigo el in primero ese in de

aquí Este porque este es un in lo

extraigo

eh Y luego creo memoria para el voy

asterisco que voy a alojar creo memoria

para para esto O sea según este valor

que ya lo puse Aquí creo memoria según

este valor un

maloc para almacenar todo este choclo

que viene acá necesito crear una memoria

lo suficientemente grande que almacene

todo esto así que por eso el siguiente

es otro receive que lo

almacena aquí porque aquí ya agregué y

lo almacena ahí y listo y retorna ese

buffer un buer que ya crea acá sí y hace

eso bueno retorna este buffer Bueno y

con este buffer que tiene el size y el

voy asterisco ya en memoria yo lo puedo

trabajar a esa altura ponele yo

Ups Ups Ups Ups a esa altura yo ya este

yo ya terminé a ver si borro todo esto

yo ya

terminé de extraer con el primer receive

y de extraer

todo y una vez que extraigo todo lo del

mensaje bueno

Eh Esto regresa y vuelve a esta línea a

esperar a que kernel en este caso le

envíe

le envíe algo porque ya se extrajo todo

básicamente correcto se extrajo todo así

que vuelve a a esa línea esperar que

kern le devuelva algo bueno y hasta que

kern le vuelva a dar lo mismo un choclo

lo primero que va a hacer

es recibir ese código de

operación recibir ese código de

operación

tu y con esta funci finidad de recibir

todo el woofer o sea en realidad debería

decir recibir el resto del woofer lo que

hace es crear una variable tipo woofer y

este size almacenarlo y este voy

asterisco en su respectivo No acá arriba

creo que está acá está mejor

sí este size almacenarlo aquí y este

todo este choclo almacenarlo aquí arriba

y listo y comienzo a trabajar con esa

variable correcto bien

bueno qué

más claro era

para bueno era para mostrarlo este aquí

directamente es igual a esto y este se

almacenamos aquí y este voy almacenamos

aquí y ya está Y con esa estructura esa

variable Pues en memoria ya utilizamos

para que nosotros queramos Bueno es es

en esencia lo que tenemos que crear

bueno Y de alguna manera ya está creado

No ese reive que recibe el resto de

eh de

estructuras Bueno ya ahora la pregunta

del millón y Qué contiene Este voy

asterisco está bien Eso es el protocolo

general como como lo recibe la pregunta

es

eh A ver si me deja

no este voy asterisco Qué contiene se

supone que ya lo extraje ya lo tengo acá

Qué contiene este Boy Stream este size

es el tamaño en bice de este Boy Stream

pero Qué contiene este Boy Stream ese

Boy Stream ese Boy asterisco es un

choclo que contiene Data Data De qué

tipo Data como esta puede contener un

entero puede contener un Win 32 un

String una cadena de caracteres o otro

choclo adicional dentro Sí eso es lo que

contiene

eh ese voy asterisco puede contener

cualquier cosa sí bien y cómo lo vamos a

guardar ahí obviamente vamos a crear las

funcionalidades para agregar a un voy

asterisco vacío sí inicialmente Este voy

asterisco va a estar

vacío Quiero agregar un in va a crecer

hasta Quiero agregar otro inom va a

crecer Quiero agregar más Data Boom y

así y así y

así obviamente todo esto va a impactar

ponerle que sea esta variable va a

impactar en este stre y en este en este

que va a ser este asterisco que va a

estar

aumentando y este si que va a estar

almacenando el tamaño en

by bien bueno Y es así es como vamos a a

generar ese vo

ese Este choclo de aquí este solo este

pedacito de

aquí solo este pedacito de aquí si es lo

que vamos a explicar ahora qué es lo que

contiene inicialmente no va a contener

nada sí no va a contener nada Pero

conforme Le vamos agregando va a ir

creciendo va a ir creciendo va a ir

creciendo podemos agregarle

in in

32 asterisco o voy asterisco

bien qué más

obviamente vamos a crear esas

funcionalidades para cargar en el wofer

en un wofer nuevo sí aprovechemos que el

wofer es una estructura que contiene

eh que contiene Ahí va que contiene un

Stream un hy asterisco y el tamaño de

ese hy asterisco que es indispensable

porque no hay función que te diga queé

tamaño hay en esta estructura de bytes

porque son

bytes bien creamos esas funcionalidades

que esas las detallo justamente aquí a

agregar in al boofer agregar un 32 al

woofer agregar Stream al woofer agregar

y vo al woofer y obviamente así como

agrego también extraer porque una vez

que lo recibe por ejemplo kernel es lo

que hace crea un buffer y le va a

agregar lo que necesite agregar in

String las cosas que necesite lo va a

agregar ese wofer para luego enviar en

memoria y una vez que lo recibe en

memoria extrae ese buffer memoria tiene

que extraer ese int ese Wi 32 ese String

en el orden en el orden

correspondiente correcto bien eh Ahora

vamos a explicar eso cómo vamos a

almacenar esto bueno en mi grupo esta

estas decisiones lo tomamos creo que en

una semana después de pelearnos un poco

con el código es tener hay que tener en

cuenta que lo aprendimos sobre la marcha

eh Cómo gestionaremos esto la forma más

estandarizada y más fácil que vimos es

hacerlo de esta forma por ejemplo hacer

nos concentraremos en

esta esto imagínate que es un genérico

no voy asterisco que puede ser cualquier

cosa puede ser un in un char un in

asterisco un in 32 type o un char

asterisco o un mismo voy asterisco y un

size Sí siempre va a estar almacenado

así este size va a contener el tamaño en

bytes de lo que viene a continu

s y así vamos a agregar ir agregando en

un voy asterisco más grande nuestro t

woofer almacenamos este

size Y luego almacenamos el el siguiente

coso

Sí por ejemplo si queremos expresar un

char asterisco guardamos el tamaño de

ese char asterisco y obviamente luego la

cadena de caracteres Si queremos agregar

un 32 almacenamos el tamaño Cómo tenemos

ese tamaño con estos 32t son 4 byes y

obviamente el número que propiamente

dicho y acá también cuando queremos

almacenar un int almacenaremos el si y

el int el si que son 4 bytes y el número

propiamente dicho y así por ejemplo

poner que esto sale No queremos

almacenar tuki lo ponemos ahí listo

almacenado con

l

eh voy a ver si

puedo Ahí va creo que era así la verdad

no me acuerdo Ahí va almacenamos ahí

ponerle que Quiero agregar otro in pues

no hay problema agregamos otro in ahí al

lado y así sucesivamente vamos a ir

agregando Quiero agregar un un esto un

char asterisco Bueno agregamos un char

asterisco que necesito al final de eso

Uy al final de eso agregar esto Pues

bueno lo agregamos al final y listo y

eso sería todo nuestro choclo vamos a

crear esas

funcionalidades para ir

eh agregando esto vamos a Ahí va a ir

agregando Primero este luego nuestro voy

asterisco nuestro Stream este o

almacenar primero estos dos Luego si

queremos agregar va a almacenar esto Si

queremos almacenar un char asterisco

tenemos su size y esto un Win 32 su size

y el valor siempre su size y el valor el

size y el valor el size el size de lo

que pesa lo que viene no esto y el size

de lo que pesa lo que viene siempre

siempre bajo ese criterio y obviamente

cuando lo extraigamos vamos a utilizar

ese mismo criterio vamos a valer no los

cuatro primeros bytes que nos van a

indicar cuántos bytes hay que hay que

extraer esto también esto por ejemplo si

la cadena caracteres tiene 25 caracteres

aquí con este est lench asterisco no nos

bota el tamaño ponerle 25 caracteres nos

va poner 25 Sí entonces Esto va a decir

25 y bueno leemos todos los 25

caracteres Bueno más el el caráter

centinela que que indica fin del Stream

también hay que

incluirlo el tamaño de este 32 también y

bueno Y así creamos las funciones para

para

Agregar

agregar Y también vamos a tener que

crear las funciones

para

extraer extraer de di buffer extraer

esas esos valores que son justamente

estas cosas que hemos propuesto acá

extraer y agregar cosas al buffer Sí

bueno una vez que ha quedado esto claro

eh vamos a explicar el código

ahora el código que hicimos

para agregar in al buffer vamos a

explicar lo que es agregar primero acá

crear boofer ya sabemos el T boofer

contiene un size y un Stream creamos

memoria para almacenar ese de woofer

samos en cero porque recién estamos

creando y el Stream en nul porque

obviamente no tiene nada el comienzo

obviamente la función para destruirlo y

aquí Cómo agregamos una función genérica

No empecemos con la función genérica

Cómo agregamos El choclo al buffer

agregamos de la siguiente forma

mira tenemos lo

siguiente primero vemos si el wofer está

vacío Obviamente si está vacío si es la

primera vez que se va a agregar es

básicamente es encontrar al wofer vacío

O sea que todavía todavía no se le

agregó nada Es decir que recién le

estamos agregando el

primer la

primera el primero par de elementos que

queremos

agregar bueno agregamos Ese par de

elementos Perdón ahí

Justo interrumpieron a ver agregamos Ese

par de

elementos

eh significa Que obviamente está vacío

no estaba así Perdón me desconcentré

estaba ahí vacío significa que ahora

queremos agregar su primer bloque de

elementos eh Si es así entonces bueno

acá detecta que inicialmente el tamaño

era cero Entonces le cre Crea una

memoria con el int y el valor si está

reservando

memoria está reservando memoria para

esto size of in y el

valor size del cho Sí bueno Y luego

copia obviamente de lo copia ahí dentro

de eso copia el el

valor

y también copia

el El choclo propiamente

dicho a ver esto Stream má 6 of in es

álgebra de punteros que también está en

las guías en las guías estas tienes que

leer todo en alguna parte está yo

recuerdo haberlo leído eh pero está está

está completamente este álgebra de

punteros que básicamente te está

diciendo si yo apunto acá pero no quiero

que escribas a partir de ahí Por qué

ponerle que yo tengo el puntero

aquí aquí en esta parte apunta yo

escribo el size este size lo escribo acá

donde apunta este lo escribo

acá

perfecto qué es lo que hace esto escribe

ahí donde apunta el Stream y

escribe el tamaño del in lo que lo pasas

por

parámetro lo escribe aquí o sea esto ya

está escrito

ahora qué Qué pasa si es que yo vos

ponés men copy acá de vuelta y copias El

choclo propiamente dicho significa que

en este puntero vas a volver a

sobreescribir sobre est esta esta línea

o sea el size y el in lo vas a

sobreescribir

acá y lo cual no queremos o sea queremos

donde apunta

desplazado una cierta cantidad de bits o

sea aquí Y a partir de aquí escribir el

dato que sigue si por eso es que se

llama álgebra de punteros a esta cosa

donde ponem Perdón acá ponemos Stream

más el size of

int o sea más esto O sea el puntero más

esta cantidad de bytes y aquí ahora está

apuntando

aquí Y a partir de aquí queremos que

escriba lo demás obviamente Y a partir

de ahí escribe El choclo y todo Bueno lo

lo correspondiente

a al dato sí eh Bueno obviamente Esto si

es que el size es cero si es que el size

no es cer0 significa que ya había

contenido escrito en en el coso y lo que

estamos haciendo es escribiéndole más

contenido Sí así que para eso se se se

utiliza el real loock real loock lo que

hace es agrandar agrandar esa porción de

memoria agrandarlo agrandarlo andarlo

según la cantidad que necesitemos de

acuerdo bien bueno

Eh bueno nos dice A cuánto más espacio

queremos agregar Obviamente le pasamos

todo el espacio que mencionamos Y

copiamos sí hay que tener cuidado en el

álgebra

de de punteros eso sí y bueno Y

actualizamos ese buffer que nos pasaron

no el size ya es más grande

eh Y nada

más y teniendo esta función genérica que

nos nos agrega en ese buffer El choclo o

el contenido que le mandemos y

obviamente el tamaño de ese choclo que

le mandemos utilizamos y le aprovechamos

para armar cargar cargar in al

wofer cargar in al wofer hace eso

eh lo que hacemos Es agregamos al

choclo le pasamos el

wofer el puntero del valor El choclo que

es la

dirección del valor y el tamaño y el

tamaño como es un int si of int y

almacena al buer si cuando cargamos 32

básicamente lo mismo un valor y cuando

cargamos este alofer básicamente lo

mismo aquí el tamaño de eslen de un

String pero también le sumamos + un por

el caráter el barra cero que indica fin

fin del Stream sí está considerado para

copiarlo

bien Eso es todo Así es como se carga

cargamos esto esto este choclo que

va de de par en par sí bien ahora Cómo

extraemos la información básicamente

Hicimos lo mismo extraer choclo del

buffer creamos una función genérica para

extraer El choclo Obviamente con

las con las eh medidas necesarias para

prevenir errores Qué pasa si el tamaño

del boofer que me pasan Yo quiero

extraerle algo y resulta que ese boofer

tiene tamaño cerero o sea básicamente

que no tiene nada ya en su mal o sea

Cómo podes extraer algo si ya ese buer

ya no tiene nada si ese buer ya fue ya

le han extraído

todo obviamente su size va a ser cero y

obviamente te tienen que avisar

que ese buffer está vacío es cierto así

que error al intentar extraer un

contenido de un t woofer vacío o Peor si

es si es menor que cer hay que loguear

bueno Y si no es nada de esto Bueno

entonces sí no el size del choclo que

como ya

sabemos si queremos exer esta parte

primero tenemos que traer siempre el

size y ahí está y luego bueno Y luego

generamos memoria para

almacenar según ese dato de aquí

almacenamos memoria para almacenar el

dato

relevante el dato per no el dato

propiamente dicho que eh que queremos

guardar sí y y para eso utilizamos este

segundo men copy bueno Y luego

redimension es lógica para redimensionar

ahora si ese nuevo size hace que el

buffer o sea o sea básicamente esto que

le acabamos de extraer al wofer hace que

el wofer esté vacío que se se igual a

cer entonces básicamente sete al woofer

liberamos memoria y retornamos ese ese

choclo que que

extrajimos pero si resulta que bueno

Obviamente si es menor que cero Hay

algún error no es cierto no nos puede

dar nunca negativo hay que logarlo bueno

Y luego

eh creamos un nuevo String para asignar

porque se supone que si ya extrajimos

este el nuevo el nuevo Buy Stream con

este size tiene que ser un uno más chico

porque esto ya lo extrajimos nos queda

Solo este solo este pedazo Bueno eso es

lo que hacemos aquí eso es lo que

hacemos aquí

aquí un malo con el nuevo si ese nuevo

si que ya sufrió la resta de esos dos

elementos copiamos en ese nuevo

size Perdón en ese nuevo nuevo Stream

copiamos el Stream anterior pero

desplazado cierta cantidad de

byes y

Nada luego liberamos

reasigna s ese nuevo stam de tal manera

que ahora ya ese ese ese s y ese Stream

ya no contemplen todo eso sino que

contemplen a partir de acá ahora y es

porque esto ya se lo extrajo si ahora el

asterisco ya está más chico nada Esos

son los controles que hace y obviamente

retorno El choclo cuando

termine bueno y basado en esa función

genérica Ya te imaginarás Qué pasa

cuando quiero extraer indel wofer bueno

como este extraer choclo del wofer es

esto y retorno un voy asterisco yo puedo

hacer como este retorno un voy asterisco

yo puedo hacer

que tratar ese voy asterisco que me

retorna como un int porque un voy

asterisco es un puntero y un int un

asterisco también es un puntero Así que

sí si este me retorna voy asterisco yo

puedo decir muy bien es un puntero y

puedo decirle que a ese puntero tratarlo

como si fuera un in asterisco y Bueno

luego asigno un valor

diferente le creo un valor a retornar y

le asigno ese el valor que extraje acá y

libero por qué hago esto porque si te

das cuenta cuando extraer choclo del

buffer

Eh Yo estoy reservando memoria ese

choclo que retorno acá esto es memoria

reservada que estoy asignando y como es

memoria reservada en algún momento tengo

que liberarlo y para no olvidarme de

liberarla en algún momento Entonces lo

que hago

es ese contenido lo guardo en una

variable

temporal libero esa memoria dinámica

bueno Y luego retorno ese valor que que

bueno que se que se que Bueno es es

parte del stack no que cuando retorna

todo este esta memoria se pierde y

retorna el valor nada más Bueno es es un

tema que tienen que estudiarlo y verlo

cuando aprendan estas estas cosas pero

pero básicamente Espero que se haya

entendido Por qué hago el free acá si

porque esta función cuando extrae El

choclo te devuelve un voy asterisco un

voy asterisco que reserva una memoria

y en algún momento tengo que liberar esa

memoria y para no olvidarme en el futuro

por eso lo libero Aquí bueno y Pero

antes rescaté ese valor que extraje aquí

y

bueno y luego lo retorno ese valor Eso

es para in por ejemplo para el Win 32 es

casi lo mismo extraer El choclo Esto me

devuelve un voy

asterisco y ese voy asterisco lo trato

como es un puntero lo puedo tratar como

un puntero in 32 que me me deja y Bueno

luego declaro una nueva variable y

asigno ese el contenido de ese valor

ahí como una variable Temporal y Bueno

luego libero Esa esa memoria porque no

te olvides que esto genera memoria

dinámica libero esa memoria y bueno

retorno ese valor que que aquí auxiliar

eh

salvé bueno para el char asterisco Si

eso sí sí o sí tengo que retornar ese

String este me devuelve un voy asterisco

que puedo tratar con un puntero a un

char asterisco bueno Y eso lo retorno

directamente porque Bueno cuando

extraigo un char ya

eh Ya será mi control el tema de cuándo

liberar ese String cuando lo deje de

usar bien y así es básicamente como

hemos armado las funcionalidades de int

Win 32 obviamente hemos creado crear

wofer qué es esto Li destruir wofer eh y

también creamos el super paquete que ya

Les explico rápidamente Cómo es acá

todas estas cositas no es que les hemos

sacado de la nada eh todas estas cosas

los hemos sacado de nuestro queridísimo

tpc aquí a ver eh utils c me aparece

eh crear conexión por ejemplo Enviar

mensaje tenemos un Send o sea aquí está

serialización paquete ahora es

explicamos crear wofer

eh También está

eh crear paquete agregar a paquete por

ejemplo Acá está el realo que les dije

que hace que aumentar el tamaño

dinámicamente una memoria Así que todas

esas funcionalidades lo hemos extraído

del tp0 no es que los nos hemos sacado

así de la nada no no no no le hemos

estudiado el tp0 a fondo y hemos

descubierto Cómo

Cómo tomar esas funcionalidades y

adecuarlas a nuestras necesidades bien

bueno por último vamos a hacer el tema

de la serialización Qué hace lo de

serialización

[Música]

bueno Qué hace lo de

serialización Ponle

que

Ponle que yo

ya estoy teniendo problemas con esto qué

[Música]

barbaridad

buenoo

ponerle que ya está en este nuestro

agregamos no con

Agregar agregar extraer cargar choclo

cargar cargar in cargamos cargamos un

montón de cosas y Se generó Esto sí

obviamente esto lo generamos en una

estructura no una estructura que es esto

y el size que contiene el tamaño porque

lo fuimos agregando y se fue

actualizando el size de nuestra

estructura

bien Pero para qué serializar si esto

queremos enviar sí pero si lo enviamos

Así nada más no va el receptor en este

caso kernel genera este buffer y se lo

envía Así nada más a memoria memoria no

va a ver Che me mandas un choclo pero no

sé cuánto

mide bueno Y vos dirás Bueno si no sabes

cuánto mide

para tengo la solución te

creo

te creo otro otro choclo igual pero que

contenga el in o sea copio El choclo y

te copio el L delante así tienes el

tamaño perfecto pero cómo distingo ahora

si se entiende no copio este choclo acá

y meto el in delante O sea primero

genero genero una una memoria dinámica

para almacenar el in y

luego agrego todo lo demás todo ese

choclo Así sé cuántos bytes tiene este

este este choclo que sigue bien pero yo

te digo Hay un montón de de tipos de

mensajes cómo voy a saber en qué orden

sacarlo Sí porque acordate que puede

puedes enviarlo aquí Según esto Según

esto Según esto sí por ejemplo acá yo

estoy marcando que me envías un pid un

int un char asterisco y un int en ese

orden puede ser que en otro por ejemplo

aquí Pon no estoy así puede ser que aquí

solo envíes

int

y y un in Pon l

no 22 que se a ponerle un registro no sé

solo esos dos valores Cómo

diferenciar porque con esto voy a

extraer un in un char y un in y aquí con

esto Con este código de operación voy

extraer Solo este y este Cómo saber en

en en dónde En dónde ubicarlo para hacer

las funcionalidades respectivas de

extracción bueno para eso está el código

de operación Así que para eso tenemos el

código de operación Así que con eso ya

estamos primero agrego el código de

operación agrego el tamaño del void y le

agrego el vo propiamente dicho y así

creamos un nuevo choclo y ese choclo

Adivinaste es lo que mandamos aquí ese

choclo es el que mandamos ahí el código

de operación ahí está el size que viene

a ser esto y ese voy asterisco que es

este de aquí todo ese choclo nuevo es el

que mandamos a memoria y memoria

Obviamente con las funcionalidades que

vimos al comienzo lo que hace es bueno

extraer este y saber dónde atenderlo y

luego terminar de extraer todo no extrae

este y según la información de este

termina de extraer lo demás y una vez

que lo tiene almacenado en una memoria

bueno eh extrae lo que necesite el in el

in y en char sí y así es como funciona

nuestra serialización eso es lo que lo

que consiste en serializar agarrar ese

voy asterisco es est estructura y crear

una estructura más grande agregando

estos dos datos al inicio s código de

operación el tamaño y el

choque Bueno eso es lo que hace nuestra

serialización serializar paquete agarra

eh

eh claro el paquete es una estructura

que

tiene un código de operación y el wofer

y dentro de ese wofer está el size y el

Stream bueno Y luego obviamente una vez

que crea es a enviar es ese nuevo choclo

más grande o sea este mega choclo con

todo dentro

este una vez que tiene eso bueno lo

envía eso y el otro lo

recibe bien Así es como

eh

eh Por

ejemplo estamos eh Ya explicaré lo que

es la consola sí solo quiero que

tengas en cuenta esto que cree una

variable tipo wofer creamos el wofer y

luego las funciones de carga cargamos un

int cargamos un

String cargamos otro in porque lo voy a

mandar en ese orde int char char int Sí

y bueno Y luego creamos el paquete con

la función crear super

paquete con el código de operación que

es uno de estos sí que lo va a recibir

memoria uno de estos códigos que lo va a

recibir

memoria y obviamente ese

ese

ese ese buffer no que se va a enviar

porque así está estipulado

en crear super paquete

eh Bueno luego en esta crear super

paquete luego enviamos paquete al F

escripto

memoria y nada y memoria obviamente

memoria lo que tiene que hacer es

extraer el código de operación y una vez

que caiga acá eh tiene que extraer en

este orden en ese mismo esto es

importante el mismo orden con que lo

mandé int String int es el mismo orden

con que tengo que sacarlo int String

in bueno acá lo que hago es recibir todo

el wofer y le mando una función para que

lo atienda y bueno te imaginarás extraer

in del wofer extraer Stream del wofer y

otra vez extraer in del wofer Sí bueno y

lo que hago es logarlo loguear esos tres

valores que extraje de ese buffer que me

llegó vamos a probarlo Espero que se

haya

entendido sí espero que Cuántos minutos

de grabación llevo 45 minutos perfecto

vamos a probarlo no nos queda otra que

probarlo A ver vamos el ZZ acá el redmi

creo que acá Ahí

va

CD perfecto vamos a dividir esto esto

esto

Perfecto dividimos

op Bueno ejecutamos

memoria ejecutamos file

System se conect esperando cpu

ejecutamos cpu

UPS

Y por último ejecutamos

kernel listo y acá

se se pone nuestra consola interactiva

Eh bueno en la siguiente video voy a

explicar cómo creer la consola

interactiva Pero bueno básicamente es

esto iniciar proceso pad size

prioridad bueno así que vamos a

hacerlo iniciar proceso

p prioridad bueno el p ponerle que sea

no

sé

archivo y aquí que sea el si que sea 120

y la

prioridad y acá te

log

el in y la

prioridad sí

eh

bien Vamos a enviarlo otra

vez Vamos a ponerle un cero más

prioridad

11 y así sucesivamente mire memoria está

recibiendo esos datos el pid bueno que

es algo que genera kernel para

identificar cada cada uno que in es un

proceso así que eso es algo servicios de

kernel que seguramente explicaré en la

próxima clase donde explique la consola

Pero bueno el tema es que recibe este

este este choclo que puse acá utn si el

pn sdo y el size 120 120 1200 que era lo

que lo que puse acá y así es como Bueno

vamos a iniciar proceso nuevamente vamos

a agregar un choclo muy

grande con mayúscula

minúsculas

eh 100 y nu prioridad y me llegó todo

ese choclo enorme el pad tucu tucu tucu

tucu el 600 Obviamente el pid 4 porque

ojo que esto de prioridad no el de

prioridad solo es para administración de

kernel El de prioridad no se envía a

memoria Sí bueno en en este caso en mi

tp bueno Y así es como enviamos a a de

kernel a memoria Sí creamos

funcionalidades para agregar el el un

char asterisco un in un in al woofer y

creamos las funciones necesarias para

extraer

extraer extraer in char asteriscos del

wofer y para poder logarlo en este caso

solo la mostramos nosotros podemos eh

usar hacer lo que queramos según lo

nuestro enunciado del tp Y eso sería

todo eso sería correspondiente a

serialización Espero que se me haya

entendido creo que esta vez lo expliqué

mejor es la segunda vez que hago este

video

eh Pero bueno en términos generales ya

explicamos Cómo llega las

funcionalidades que extraen esto y las

funcionalidades que extraen lo demás hay

funcionalidades para agregar cargar eh

cosos al wofer y funcionalidades para

extraer

cosos del buffer sí

Bueno espero que se haya entendido nos

vemos en el próximo y creo que último

video que es de consola me parece así

que sin más adiós