\newpage Ejercicio 8 ==== A continuación se muestran los diferentes casos de prueba realizados para comparar los diferentes tipos de schedulers. Se eligieron los siguientes casos de prueba ya que creemos que son los casos que más se acercan a la realidad: * __Uso intensivo CPU:__ Para simular casos de, por ejemplo, procesamiento de imágen o video. * __Uso intensivo IO:__ Para simular situaciones en las que se lea mucha información del disco continuamente (como falta de memoria RAM). * __Picos esporádicos CPU con IO:__ Para simular casos de uso normal de usuario. Para cada caso se creó un lote de tareas específicos llamados `cpu.tsk`, `cpu_ioh.tsk` y `cpuh_io.tsk` respectivamente. En todos los gráficos de barras que se muestran a continuación se muestran los promedios obtenidos de cada ejecución. Cada barra representa que hizo cada _ticks_ de CPU que hubo. ### Uso intensivo CPU #### Single core ![](informe/imagenes/caso_cpu_1_1.png) Caso "básico" con 12 taskCPU, 1 core, _context switch_ de 2 ticks, podemos observar que **FCFS**, **RSJF** y **SJF** se comportan de manera *muy* similar. En los tres casos se ve que la latencia y tiempo ready (_waiting time_) son muy similares. Esto se debe al tipo de implementación es similar, esperando a que termine cada tarea para desalojarla. En el caso del RSJF, como son tareas con CPU intensivo, no hay tantos cambios de contexto. En cambio, RR tiene una latencia *mucho* menor (~la mitad), pero por la naturaleza de este scheduler el _mean turnaround time_ es mucho más alto (~7x). \newpage ![](informe/imagenes/caso_cpu_1_2.png) A diferencia del caso anterior, el context switch en esta prueba cuesta *12* ticks. La única modificación que hicimos fue mantener la relación entre ticks de context switch y quantums ( (2,5) => (12,30) ) En éste caso se puede ver que todos los schedulers se comportan de manera similar, ya que como el _quantum_ es mayor que el tiempo que demora cada tarea en completarse, todas se comportan como un scheduler __FIFO__. #### Multi core ![](informe/imagenes/caso_cpu_4_1.png) Caso "básico" con 12 taskCPU, 4 core, context switch de 2 ticks, podemos observar que FCFS y SJF se comportan de manera *muy* similar. RSJF: Incrementa ligeramente la latencia y el turnaround comparado a SJF. RR: tiene una latencia *mucho* menor (~la mitad), pero por la naturaleza de este scheduler el mean turnaround time es mucho más alto (~2.5x) que en los otros schedulers. ![](informe/imagenes/caso_cpu_4_2.png) A diferencia del caso anterior, el context switch en esta prueba cuesta *12* ticks. La única modificación que hicimos fue mantener la relación entre ticks de context switch y quantums ( (2,5) => (12,30) ) En éste caso se puede ver que FCFS, RR y SJF se comportan de manera similar. Como en casos anteriores, el hecho de que el _quantum_ sea muy alto, hace que todos los scheduler se comporten como el scheduler __FIFO__. ### Uso intensivo IO #### Single core ![](informe/imagenes/caso_ioh_1_1.png) En este caso hay 15 tareas, 11 son TaskBatch y 4 TaskCPU. Tantos IO hacen que la performance del scheduler RR sea mejor de lo esperado (context switch barato en relacion a duracion de IO). ![](informe/imagenes/caso_ioh_1_2.png) En este caso hay 15 tareas, 11 son TaskBatch y 4 TaskCPU. Tantos IO hacen que la performance del scheduler RR sea pésima (context switch caro en relacion a duracion de IO). \newpage #### Multi core ![](informe/imagenes/caso_ioh_4_1.png) En este caso se puede ver que el scheduler _Round Robin_, aunque con menor latencia, tiene mucho _waiting time_. Esto está relacionado con los informado en el _ejercicio 4_, que al no tener _CPU pinning_ pierde la mayor parte del tiempo haciendo _CPU switch_. \newpage ![](informe/imagenes/caso_ioh_4_2.png) En este caso se puede ver que el scheduler _Round Robin_, aunque con menor latencia, tiene mucho _waiting time_. Esto está relacionado con los informado en el _ejercicio 4_, que al no tener _CPU pinning_ pierde la mayor parte del tiempo haciendo _CPU switch_. ### Picos esporádicos CPU con IO \newpage #### Single core ![](informe/imagenes/caso_cpuh_1_1.png) Al igual que los otros casos en 1 core, FCFS, RSJF y SJF se comportan de manera similar. RR: La latencia se reduce como es esperado, pero incrementan READY y turnaround. ![](informe/imagenes/caso_cpuh_1_2.png) Al igual que los otros casos en 1 core, FCFS, RSJF y SJF se comportan de manera similar. RR: La cantidad de tareas(15), llamadas a IO y costo alto de context switch hace que este sea un caso muy malo para RR. #### Multi core ![](informe/imagenes/caso_cpuh_4_1.png) Los scheduler FCFS, RSJF y SJF se comportan de manera similar (Con un quantum grande se comportan como el FCFS). RR: La cantidad de tareas, llamadas a IO y costo alto de context switch hace que este sea un caso muy malo para RR. \newpage ![](informe/imagenes/caso_cpuh_4_2.png) Los scheduler FCFS, RSJF y SJF se comportan de manera similar (Con un quantum grande se comportan como el FCFS). RR: La cantidad de tareas, llamadas a IO y costo alto de context switch hace que este sea un caso muy malo para RR.