Deploying to gh-pages from @ ef16474 🚀

so2425/comunicación_mediante_paso_de_mensajes.html

@@ -1286,12 +1286,12 @@ <h4 id="_señales_en_sistemas_operativos_posix"><a class="anchor" href="#_señal
 </table>
 </div>
 <div class="paragraph">
-<p>El ejemplo en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap10/mqueue-server.cpp">mqueue-server.cpp</a> y en otros ejemplos de este capítulo, utiliza señales para manejar <code>SIGINT</code>, <code>SIGTERM</code> y para mostrar la hora periódicamente.
-El código dedicado a eso está en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/common/timeserver.c">timeserver.c</a> y se comparte entre todos los ejemplos.
-En todos los casos se evita usar <code>SA_RESTART</code> porque interesa que el proceso interrumpa lo que esté haciendo cuando llegue una señal para terminar.</p>
+<p>El ejemplo en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap10/mqueue-server.cpp">mqueue-server.cpp</a> y en otros ejemplos de este capítulo, utiliza señales para mostrar la hora periódicamente.
+El código dedicado a eso está en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/common/timeserver.cpp">timeserver.cpp</a> y se comparte entre todos los ejemplos.
+En todos los casos se usa <code>SA_RESTART</code> porque interesa que se maneje la señal de <code>SIGARLM</code> para mostrar la hora, sin interrumpir cualquier llamada al sistema en la que puede estar esperando el proceso cuando llegue la señal.</p>
 </div>
 <div class="paragraph">
-<p>En <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap10/signals.c">signals.c</a> hay un programa de ejemplo que muestra cómo manejar las señales del sistema y que sirve para ver cómo funcionan.
+<p>En <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap10/signals.cpp">signals.cpp</a> hay un programa de ejemplo que muestra cómo manejar las señales del sistema y que sirve para ver cómo funcionan.
 Solo hay que ejecutarlo y luego enviarle señales con el comando <code>kill</code> desde otra terminal.
 En este caso si se usa <code>SA_RESTART</code>, porque el programa debe estar esperando la pulsación de una tecla con <code>getc()</code> y no nos interesa que deje de hacerlo cuando llegue una señal.</p>
 </div>
@@ -1408,8 +1408,8 @@ <h4 id="_tuberías"><a class="anchor" href="#_tuberías"></a>10.5.3. Tuberías</
 </div>
 <div class="paragraph">
 <p>Por otro lado, las tuberías con nombre permiten que un proceso se comunique con cualquier otro, solo con conocer la ruta de la tubería.
-En <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap10/fifo-client.c">fifo-server.c</a> tenemos un ejemplo de un programa que muestra la hora del sistema de forma periódica, mientras espera órdenes de una tubería que sirve de canal de control remoto.
-Los programas en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap10/fifo-client.c">fifo-client.c</a> y <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap10/fifo-client.cpp">fifo-client.cpp</a> pueden conectarse a esa tubería y mandar el comando que hace terminar <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap10/fifo-client.c">fifo-server.c</a>.</p>
+En <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap10/fifo.cpp">fifo.cpp</a> tenemos un ejemplo de un programa que muestra la hora del sistema de forma periódica, mientras espera órdenes de una tubería que sirve de canal de control remoto.
+El programa en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap10/fifo-control.cpp">fifo-control.cpp</a> puede conectarse a esa tubería y mandar el comando que hace terminar <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap10/fifo.cpp">fifo.cpp</a>.</p>
 </div>
 </div>
 <div class="sect3">

so2425/memoria_compartida.html

@@ -530,10 +530,8 @@ <h3 id="_memoria_compartida_con_nombre"><a class="anchor" href="#_memoria_compar
 Para redimensionarlo se utiliza <a href="https://man7.org/linux/man-pages/man2/ftruncate.2.html">ftruncate()</a>, que lo que necesita es el descriptor del objeto y el nuevo tamaño.</p>
 </div>
 <div class="paragraph">
-<p>En <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared-memory-server.c">shared-memory-server.c</a> y <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared-memory-client.cpp">shared-memory-client.cpp</a> se puede ver el ejemplo de un programa que muestra periódicamente la hora del sistema.
-En este caso controlado por otro mediante memoria compartida.
-Ambos programas usan la clase definida en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared_memory.hpp">shared_memory.hpp</a> para gestionar el objeto de memoria compartida.
-Sus métodos muestran de forma práctica cómo utilizar las llamadas al sistema comentadas.</p>
+<p>En <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared-memory.cpp">shared-memory.cpp</a> se puede ver el ejemplo de un programa que muestra periódicamente la hora del sistema.
+En este caso controlado por <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared-memory-control.cpp">shared-memory-control.cpp</a> mediante memoria compartida.</p>
 </div>
 <div class="paragraph">
 <p>En Microsoft Windows también se utiliza <a href="https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createfilemappinga">CreateFileMapping()</a> para crear el objeto de memoria compartida con nombre.

so2425/planificación_de_la_cpu.html

@@ -1914,11 +1914,11 @@ <h5 id="_implementación_básica"><a class="anchor" href="#_implementación_bás
 </div>
 <div class="stemblock">
 <div class="content">
-\[g = \text{min}\left(n, \text{floor}\left(\frac{L}{M}\right)\right)\]
+\[g = \text{max}\left(n, \text{floor}\left(\frac{L}{M}\right)\right)\]
 </div>
 </div>
 <div class="paragraph">
-<p>de forma que siempre haya suficientes porciones para que cada proceso pueda tener al menos una, limitando por debajo el número de porciones a repartir a \$\text{floor}(L / M)\$.</p>
+<p>de forma que siempre haya suficientes porciones \$M\$ para que cada proceso pueda tener al menos una, limitando por debajo el número de porciones a repartir a \$\text{floor}(L / M)\$.</p>
 </div>
 <div class="paragraph">
 <p>Cuando se escoge un proceso para su ejecución, se calcula el cuanto real \$t_{i}\$ durante el que se le asignará la CPU:</p>
@@ -1931,6 +1931,10 @@ <h5 id="_implementación_básica"><a class="anchor" href="#_implementación_bás
 <div class="paragraph">
 <p>de forma que se reparten las \$g\$ porciones entre los \$n\$ procesos.</p>
 </div>
+<div class="paragraph">
+<p>Si hay muchos procesos, \$g = n\$, por lo que a cada proceso se le asigna un tiempo de CPU de \$M\$.
+Si hay pocos procesos, \$g = \text{floor}(L / M)\$, por lo que a cada proceso se le asignan varias porciones \$M\$ de tiempo de CPU del periodo \$L\$.</p>
+</div>
 </div>
 <div class="sect4">
 <h5 id="_planificación_equitativa_ponderada"><a class="anchor" href="#_planificación_equitativa_ponderada"></a>Planificación equitativa ponderada</h5>

so2425/procesos.html

@@ -806,10 +806,10 @@ <h5 id="_árbol_de_procesos"><a class="anchor" href="#_árbol_de_procesos"></a>
 </div>
 </div>
 <div class="sect4">
-<h5 id="_cómo_obtienen_los_procesos_hilos_los_recursos_que_necesitan"><a class="anchor" href="#_cómo_obtienen_los_procesos_hilos_los_recursos_que_necesitan"></a>Cómo obtienen los procesos hilos los recursos que necesitan</h5>
+<h5 id="_cómo_obtienen_los_procesos_hijos_los_recursos_que_necesitan"><a class="anchor" href="#_cómo_obtienen_los_procesos_hijos_los_recursos_que_necesitan"></a>Cómo obtienen los procesos hijos los recursos que necesitan</h5>
 <div class="paragraph">
 <p>Hay varios aspectos en la creación de los procesos que pueden variar de un sistema operativo a otro.
-Uno de ellos es cómo obtienen los procesos hilos los recursos que necesitan para hacer su trabajo.</p>
+Uno de ellos es cómo obtienen los procesos hijos los recursos que necesitan para hacer su trabajo.</p>
 </div>
 <div class="paragraph">
 <p>Fundamentalmente existen dos alternativas:</p>
@@ -1192,7 +1192,7 @@ <h5 id="_windows_api_2"><a class="anchor" href="#_windows_api_2"></a>Windows API
 <div class="title">Ejemplo 9.1. Crear un proceso usando Windows API</div>
 <div class="content">
 <div class="paragraph">
-<p>El código fuente completo de este ejemplo está disponible en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap09/createprocess.c">createprocess.c</a>.</p>
+<p>El código fuente completo de este ejemplo está disponible en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap09/createprocess.cpp">createprocess.cpp</a>.</p>
 </div>
 <div class="listingblock">
 <div class="content">
@@ -1310,7 +1310,7 @@ <h5 id="sect-procesos-posix-api"><a class="anchor" href="#sect-procesos-posix-ap
 <div class="title">Ejemplo 9.2. Crear un proceso en sistemas POSIX</div>
 <div class="content">
 <div class="paragraph">
-<p>El código fuente completo de este ejemplo está disponible en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap09/fork.c">fork.c</a>.</p>
+<p>El código fuente completo de este ejemplo está disponible en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap09/fork.cpp">fork.cpp</a>.</p>
 </div>
 <div class="listingblock">
 <div class="content">
@@ -1458,7 +1458,7 @@ <h5 id="sect-procesos-posix-api"><a class="anchor" href="#sect-procesos-posix-ap
 <div class="title">Ejemplo 9.3. Ejecutar otro programa en un proceso nuevo en sistemas POSIX</div>
 <div class="content">
 <div class="paragraph">
-<p>El código fuente completo de este ejemplo está disponible en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap09/fork-exec.c">fork-exec.c</a>.</p>
+<p>El código fuente completo de este ejemplo está disponible en <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap09/fork-exec.cpp">fork-exec.cpp</a>.</p>
 </div>
 <div class="listingblock">
 <div class="content">

so2425/sincronización.html

@@ -910,10 +910,10 @@ <h4 id="_ejemplos_del_uso_de_semáforos"><a class="anchor" href="#_ejemplos_del_
 <p>En el ejemplo <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/anom-shared-memory.cpp">anom-shared-memory.cpp</a> de comunicación mediante memoria compartida, se usa un <strong>semáforo</strong> para que el proceso hijo indique al proceso padre que ha terminado de calcular el factorial y el resultado ya está en la memoria.</p>
 </div>
 <div class="paragraph">
-<p>En <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared-memory-server.c">shared-memory-server.c</a> está el ejemplo completo de un programa que muestra periódicamente la hora del sistema y que puede ser controlado remotamente, mediante memoria compartida, con un cliente como el de <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared-memory-client.cpp">shared-memory-client.cpp</a>.</p>
+<p>En <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared-memory.cpp">shared-memory.cpp</a> está el ejemplo completo de un programa que muestra periódicamente la hora del sistema y que puede ser controlado remotamente, mediante memoria compartida, con un programa como el de <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared-memory-control.cpp">shared-memory-control.cpp</a>.</p>
 </div>
 <div class="paragraph">
-<p>Para enviar los mensajes entre el cliente y el servidor, en la memoria compartida se reserva hueco para un búfer en el que el cliente copia el comando que quiere enviar y para dos <strong>semáforos</strong>:</p>
+<p>Para enviar los mensajes entre ambos programas, en la memoria compartida se reserva hueco para un búfer, en el que el programa de control copia el comando que quiere enviar, y para dos <strong>semáforos</strong>:</p>
 </div>
 <div class="listingblock">
 <div class="content">
@@ -930,41 +930,41 @@ <h4 id="_ejemplos_del_uso_de_semáforos"><a class="anchor" href="#_ejemplos_del_
 <tr>
 <td><i class="conum" data-value="1"></i><b>1</b></td>
 <td>Indica cuándo <code>command_buffer</code> está vacío, así que se inicializa a 1.
-El cliente usa <a href="https://man7.org/linux/man-pages/man3/sem_wait.3.html">sem_wait()</a> en este <strong>semáforo</strong> antes de escribir un nuevo comando en <code>command_buffer</code>:
+El programa de control usa <a href="https://man7.org/linux/man-pages/man3/sem_wait.3.html">sem_wait()</a> en este <strong>semáforo</strong> antes de escribir un nuevo comando en <code>command_buffer</code>:
 <div class="ulist">
 <ul>
 <li>
-<p>Si el <strong>semáforo</strong> está a 0, el cliente pasa y escribe el comando.
+<p>Si el <strong>semáforo</strong> está a 0, el programa de control pasa y escribe el comando.
 Después llama a <a href="https://man7.org/linux/man-pages/man3/sem_post.3.html">sem_post()</a> en <code>ready</code>.</p>
 </li>
 <li>
-<p>Si el <strong>semáforo</strong> está a 1, el cliente queda bloqueado y tiene que esperar a que el servidor use <a href="https://man7.org/linux/man-pages/man3/sem_post.3.html">sem_post()</a> sobre el mismo <strong>semáforo</strong>.
-El servidor lo hace después de leer el comando para interpretarlo.</p>
+<p>Si el <strong>semáforo</strong> está a 1, el programa de control queda bloqueado y tiene que esperar a que el servidor use <a href="https://man7.org/linux/man-pages/man3/sem_post.3.html">sem_post()</a> sobre el mismo <strong>semáforo</strong>.
+El programa controlado lo hace después de leer el comando para interpretarlo.</p>
 </li>
 </ul>
 </div></td>
 </tr>
 <tr>
 <td><i class="conum" data-value="2"></i><b>2</b></td>
 <td>Indica cuándo <code>command_buffer</code> tiene un comando, así que se inicializa a 0.
-El servidor usa <a href="https://man7.org/linux/man-pages/man3/sem_wait.3.html">sem_wait()</a> en este <strong>semaforo</strong> antes de leer el comando en <code>command_buffer</code> para interpretarlo:
+El programa controlado usa <a href="https://man7.org/linux/man-pages/man3/sem_wait.3.html">sem_wait()</a> en este <strong>semaforo</strong> antes de leer el comando en <code>command_buffer</code> para interpretarlo:
 <div class="ulist">
 <ul>
 <li>
-<p>Si el <strong>semáforo</strong> está a 0, el cliente pasa y lee el comando.
+<p>Si el <strong>semáforo</strong> está a 0, el programa de control pasa y lee el comando.
 Después llama a <a href="https://man7.org/linux/man-pages/man3/sem_post.3.html">sem_post()</a> en <code>empty</code>.</p>
 </li>
 <li>
-<p>Si el <strong>semáforo</strong> está a 1, el servidor queda bloqueado y tiene que esperar a que el cliente use <a href="https://man7.org/linux/man-pages/man3/sem_post.3.html">sem_post()</a> sobre el mismo <strong>semáforo</strong>.
-El cliente lo hace después de escribir un nuevo comando en <code>command_buffer</code>.</p>
+<p>Si el <strong>semáforo</strong> está a 1, el programa controlado queda bloqueado y tiene que esperar a que el programa de control use <a href="https://man7.org/linux/man-pages/man3/sem_post.3.html">sem_post()</a> sobre el mismo <strong>semáforo</strong>.
+El programa de control lo hace después de escribir un nuevo comando en <code>command_buffer</code>.</p>
 </li>
 </ul>
 </div></td>
 </tr>
 </table>
 </div>
 <div class="paragraph">
-<p>El detalle de cómo cliente y servidor usan ambos semáforos, se puede ver en el código de <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared-memory-client.cpp">shared-memory-client.cpp</a> y <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared-memory-server.c">shared-memory-server.c</a>, respectivamente.</p>
+<p>El detalle de cómo ambos programas usan los semáforos, se puede ver en el código de <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared-memory-control.cpp">shared-memory-control.cpp</a> y <a href="https://github.com/ull-esit-sistemas-operativos/ssoo-ejemplos/blob/so2425/src/cap11/shared-memory.cpp">shared-memory.cpp</a>, respectivamente.</p>
 </div>
 <div class="paragraph">
 <p>Finalmente, para resolver el <strong>problema del productor-consumidor</strong> tenemos que considerar que:</p>