Detalles

informe/8-informe.md

@@ -52,8 +52,12 @@ quantums y para experimentar utilizamos el siguiente lote:
 
 A1
 
+El siguiente grafico muestra los valores promedios obtenidos para cada scheduler.
+
 ![Ejercicio 8 - CPU Liviano 1 Core](informe/imagenes/caso_8A1.png)
 
+A continuación se puede ver una tabla con los valores de *Latencia*, *Turnaround* y tiempo *Ready*.
+
 | Métrica        | SchedRR         |SchedFCFS |SchedSJF       | SchedRSJF |
 |----------------|-----------------|----------|---------------|-----------|
 |M. Latency      | 14              | 14       | 16            | 12        |
@@ -61,8 +65,15 @@ A1
 |M. Turnaround   | 5               | 4        | 4             | 7         |
 |Idle            | 1               | 1        | 1             | 1         |
 
+De los diagramas de Gantt (*ver anexo*) y de los valores calculados se puede observar que
+todos los schedulers se comportan de manera similar (*como un FCFS*), ya que hasta el *Round Robin*
+deja terminar las tareas debido a que tienen una duración menor al quantum del mismo.
+
+
 A2
 
+A continuación se ejecuta el mismo lote pero en schedulers de dos cores.
+
 ![Ejercicio 8 - CPU Liviano 2 Core](informe/imagenes/caso_8A2.png)
 
 | Métrica       | SchedRR | SchedFCFS | SchedSJF | SchedRSJF |
@@ -72,6 +83,11 @@ A2
 | M. Turnaround | 6       | 4         | 4        | 4         |
 | Idle          | 3       | 5         | 1        | 5         |
 
+
+Se puede observar que en todos los casos, el aumento de cores beneficia en mas de un 100% 
+los tiempos de ejecución de cada scheduler, ninguno beneficiandose más en particular.
+
+
 #### Escenario B:
 
 En este escenario, nos plantemos utilizar varias tasks de tamaño grande en relación al 
@@ -87,9 +103,9 @@ quantums y para experimentar utilizamos el siguiente lote:
 | 4    | TaskCPU     | 20           | 20 |
 | 5    | TaskCPU     | 20           | 24 |
 
-![Ejercicio 8 - CPU Pesado 1 Core](informe/imagenes/caso_8B1.png)
-![Ejercicio 8 - CPU Pesado 2 Core](informe/imagenes/caso_8B2.png)
 
+**1 Core**
+![Ejercicio 8 - CPU Pesado 1 Core](informe/imagenes/caso_8B1.png)
 
 | Métrica       | SchedRR | SchedFCFS | SchedSJF | SchedRSJF |
 |---------------|---------|-----------|----------|-----------|
@@ -98,6 +114,14 @@ quantums y para experimentar utilizamos el siguiente lote:
 | M. Turnaround | 119     | 20        | 20       | 35        |
 | Idle          | 1       | 1         | 1        | 1         |
 
+En procesos con un tamaño superior a los quantums, se puede observar que todos los schedulers *no reentrantes* 
+siguen comportandose como el scheduler *FCFS*, ya que no dependen del quantum o del orden.
+En particular se puede ver que la latencia del *Round Robin* es 3 veces menor que el resto, pero el tiempo *Ready*
+y *Turnaround* llega a ser más del doble que el resto de las tareas.
+
+**2 Cores**
+![Ejercicio 8 - CPU Pesado 2 Core](informe/imagenes/caso_8B2.png)
+
 | Métrica       | SchedRR | SchedFCFS | SchedSJF | SchedRSJF |
 |---------------|---------|-----------|----------|-----------|
 | M. Latency    | 9       | 13        | 15       | 12        |
@@ -105,6 +129,9 @@ quantums y para experimentar utilizamos el siguiente lote:
 | M. Turnaround | 122     | 20        | 20       | 24        |
 | Idle          | 7       | 9         | 17       | 3         |
 
+Al duplicar la cantidad de cores vuelve a verse un aumento sustancial en la latencia y tiempos de ejecución
+de cada scheduler, excepto en el *Round Robin*, donde los beneficios son casi despreciables (salvo en la latencia).
+
 
 #### Escenario C: