Informe técnico - simulador de planificación de CPU, sistema de archivos virtual y GUI web en Django

Este informe documenta el repositorio proyecto-final-so, que integra un simulador discreto de planificación de procesos (FCFS, SJF y Round Robin) y un sistema de archivos virtual operado vía CLI, así como la GUI web desarrollada en Django que expone la lógica del simulador y del sistema de archivos a través de una interfaz web. Se incluyen detalles de arquitectura, decisiones de diseño, flujo de ejecución y evidencias de prueba.

La GUI de escritorio referenciada en algunos demos (PyWebview) no se encuentra en este árbol; la GUI final en producción corresponde a una aplicación web en Django descrita en este informe.

Objetivo y alcance

• Desarrollar un entorno didáctico para estudiar algoritmos clásicos de planificación de CPU y un sistema de archivos simplificado con permisos básicos.
• Proveer:
  • Un adaptador CLI unificado que permita ejecutar simulaciones y explorar el sistema de archivos virtual.
  • Una GUI web basada en Django que permita a los estudiantes interactuar con los algoritmos y el sistema de archivos desde un navegador.
• Incluir escenarios de ejemplo, scripts de demostración y pruebas automatizadas para validar los módulos nucleares.

Arquitectura general

• Dominio core (core/): dos subdominios aislados (scheduler y fs) que contienen modelos y lógica de negocio, independientes de la interfaz (CLI o web).
• Servicios de aplicación (core/services): fachadas SimService y FsService que traducen peticiones externas (CLI o web) a acciones de dominio.
• Adaptadores (adapters/):
  • CLI principal (adapters/cli/main.py) y documentación de uso (adapters/cli/CLI_README.md, FLUJO_EJECUCION_CLI.md).
  • La GUI web usa la misma lógica de dominio, pero a través de un backend Django externo (ver sección “GUI web en Django”).
• Datos (data/examples): escenarios CSV/JSON listos para alimentar el simulador.
• Demos y utilidades: demo_cli.py, enhanced_demo.py, test_filesystem.py para recorridos end-to-end y pruebas rápidas.

Detalle técnico: simulador de planificación (core/scheduler)

Algoritmos (core/scheduler/algorithms)

• FCFSAlgorithm: no expropiativo, respeta orden de llegada.
• SJFAlgorithm: no expropiativo, elige menor ráfaga restante con estabilidad en empates.
• RoundRobinAlgorithm: expropiativo, quantum configurable; el time_slice del simulador puede sobrescribir el valor.
• SchedulingDecision define la interfaz común (next_process, preempt_current, timeslice).

Ciclo de simulación (core/scheduler/simulator.py)

• SimulationConfig agrupa algoritmo, time_slice, max_time y parámetros de I/O (media/desviación de intervalo y duración, máximo de eventos, habilitado).
• En cada tick:
  • Se encolan llegadas.
  • Se avanza I/O de bloqueados.
  • Se reingresan procesos desbloqueados.
  • El algoritmo decide el siguiente PCB.
  • Se consume CPU, se registran context_switches y busy_time.
  • Se calculan tiempos de finalización, espera y retorno.
• Si se supera max_time, la simulación corta sin completar procesos restantes.

Modelo de procesos (core/scheduler/pcb.py)

• El PCB contiene tiempos de llegada/ráfaga, prioridad opcional, y métricas derivadas (response_time, waiting_time, turnaround_time).
• Genera agendas de I/O pseudoaleatorias acotadas a la ráfaga total; io_request_due y tick_io mueven el proceso entre READY y BLOCKED.

Colas y estados (core/scheduler/queues.py, core/scheduler/states.py)

• Colas ReadyQueue y BlockedQueue sobre deque.
• Estados finitos NEW, READY, RUNNING, BLOCKED, TERMINATED.

Métricas (core/scheduler/metrics.py)

• SimulationMetrics.from_pcbs deriva métricas por proceso y agrega throughput, utilización de CPU y cambios de contexto.

Pruebas unitarias (core/scheduler/tests/test_scheduler.py)

• Orden FCFS.
• Desempate estable SJF.
• Respeto de quantum y time_slice en RR.
• Flujo determinista de I/O bloqueado/desbloqueado.
• Corte por max_time.
• Procesos de ráfaga cero.

Detalle técnico: sistema de archivos virtual (core/fs)

Modelos (core/fs/models.py)

• Directory y File heredan de FileSystemEntity.
• Mantienen propietario, permisos y construcción de rutas absolutas.

Permisos (core/fs/permissions.py)

• PermissionSet con banderas rwx solo para el propietario.
• Todas las operaciones validan lectura/escritura/ejecución respecto al usuario activo.

Operaciones (core/fs/ops.py)

• Comandos: ls, cd, pwd, mkdir, touch, cat, write, rm, tree, resolve.
• Soporte de rutas absolutas y relativas con . y ...
• Validación estricta de tipos y permisos.
• Particularidades:
  • mkdir, touch y write requieren que el directorio padre exista.
  • rm acepta recursive solo vía argumento nombrado (la shell actual no parsea -r).
  • No hay persistencia entre sesiones ni multiusuario real: todo es en memoria.

Renderizado de árbol (core/fs/tree_renderer.py)

• render_tree recorre DFS priorizando directorios.
• Emite conectores estilo comando tree para visualización jerárquica.

Servicios y adaptadores

SimService (core/services/sim_service.py)

Traduce un SimulationRequest en PCBs, instancia el algoritmo solicitado (fcfs, rr, sjf), arma el SchedulerSimulator y retorna SimulationMetrics.

FsService (core/services/fs_service.py)

Mapea comandos de texto a métodos de FileSystemOps y normaliza las salidas para la CLI o para cualquier capa superior (por ejemplo, vistas Django).

CLI (adapters/cli/main.py)

• Subcomando sim:
  • --algo (fcfs|rr|sjf)
  • --input (CSV/JSON pid,arrival,burst[,priority])
  • --quantum obligatorio para rr.
• Subcomando fs:
  • Abre shell interactiva con prompt fs:<ruta>.
  • Comandos: ls, cd, pwd, mkdir, touch, cat, write, rm, tree, help, exit.
  • No existe parser de flags; los argumentos se pasan literales a FileSystemOps.
• format_metrics imprime una tabla por proceso y métricas agregadas (throughput, utilización de CPU, promedios de tiempos y cambios de contexto).
• Documentación complementaria en adapters/cli/CLI_README.md y FLUJO_EJECUCION_CLI.md (instrucciones paso a paso y sesiones de ejemplo).

GUI web en Django

Además de la CLI, el proyecto cuenta con una interfaz gráfica web (GUI) que permite ejecutar los algoritmos de planificación y visualizar el sistema de archivos virtual desde el navegador.

• URL de acceso a la GUI
  Sitio desplegado: https://so.cerebria.co
• Repositorio de la GUI web
  Código fuente: https://github.com/DieGOD24/backend_so/tree/main

Tecnologías utilizadas

• Lenguaje: Python 3.8+
• Backend: Django 5+
  • Vistas y endpoints que consumen la lógica del simulador y del sistema de archivos.
  • Adaptadores que invocan los servicios de dominio (SimService y FsService) para mantener una única fuente de verdad.
• Frontend:
  • HTML y templates de Django.
  • Formularios y vistas para:
    • Configurar parámetros de simulación (algoritmo, quantum, escenarios de entrada).
    • Visualizar resultados: métricas agregadas, cronogramas de ejecución, líneas de tiempo y tablas por proceso.
    • Interactuar de forma básica con el sistema de archivos virtual (listados, creación de archivos/directorios, etc.).
• La GUI adapta la lógica desarrollada por los compañeros en proyecto-final-so para que se ejecute de manera integrada en el ecosistema Django, sin duplicar la lógica del dominio.

Integración con el dominio

• El backend Django actúa como otra capa de presentación sobre el mismo dominio:
  • Las vistas traducen las solicitudes HTTP en objetos de solicitud interna (por ejemplo, SimulationRequest).
  • Se invocan los servicios SimService/FsService.
  • Se formatean las respuestas para mostrarlas en plantillas HTML.
• De esta forma, se garantiza:
  • Consistencia entre la ejecución por CLI y por web.
  • Reutilización del código de negocio.
  • Separación de responsabilidades (dominio, aplicación, presentación).

Datos, demos y pruebas de soporte

Escenarios de entrada (data/examples)

• scenario1.csv, scenario3.csv: tablas pid/llegada/ráfaga/prioridad.
• scenario2.json: lista de jobs.
• Permiten validar el comportamiento de los algoritmos bajo diferentes configuraciones.

Demos

• demo_cli.py: ejecuta simulaciones de muestra y muestra instrucciones para el shell del sistema de archivos.
• enhanced_demo.py: imprime comandos listos para probar algoritmos y CLI; menciona una GUI PyWebview (que no forma parte de este repositorio, dado que la GUI final se implementó como app web en Django).

Instalación y ejecución recomendada (CLI)

python -m pip install -r requirements.txt

# Simulador
python -m adapters.cli.main sim --algo fcfs --input data/examples/scenario1.csv
python -m adapters.cli.main sim --algo rr --quantum 2 --input data/examples/scenario2.json

# Shell del sistema de archivos
python -m adapters.cli.main fs --user alice

Para validar el simulador, ejecutar:

python -m pytest core/scheduler/tests/test_scheduler.py

Para la GUI en Django, seguir las instrucciones del repositorio https://github.com/DieGOD24/backend_so/tree/main (instalación de dependencias, migraciones, ejecución de manage.py runserver, etc.).

Limitaciones y consideraciones

• Los algoritmos se ejecutan en un modelo discreto simplificado:
  • No hay planificación multinúcleo.
  • No existen prioridades dinámicas ni envejecimiento.
• La I/O se modela con agendas discretas y pseudoaleatorias:
  • No hay dispositivos reales ni latencias de hardware.
• El sistema de archivos es:
  • Volátil (en memoria).
  • Monousuario lógico.
  • Sin persistencia ni cuotas.
• En la shell actual:
  • rm no acepta banderas; el borrado recursivo solo se expone por código (recursive=True).
• La GUI web se orienta a fines didácticos:
  • No está pensada como panel de administración de producción.
  • Su objetivo principal es apoyar la comprensión de los conceptos de planificación de CPU y manejo de sistemas de archivos.

Autoría y roles

• Desarrollo del simulador de planificación de CPU: Kevin Esguerra Cardona
• Desarrollo del sistema de archivos: Maicol
• Desarrollo de la CLI: Isabella
• Desarrollo de la GUI web (Django, HTML templates) y despliegue en so.cerebria.co: Diego

Referencia y contexto académico

• Repositorio simulador + FS (núcleo y CLI): https://github.com/porgetit/proyecto-final-so/
• Repositorio GUI web en Django: https://github.com/DieGOD24/backend_so/tree/main
• Sitio web de la GUI: https://so.cerebria.co
• Proyecto desarrollado como trabajo final para la materia de Sistemas Operativos del programa de Ingeniería en Sistemas y Computación de la Universidad Tecnológica de Pereira, bajo la dirección del ingeniero Juan García.

Disclaimer sobre uso de IA

Este informe y parte del soporte documental fueron preparados con asistencia de agentes de IA. Se recomienda verificar y validar los detalles técnicos antes de utilizarlos en entornos de producción o como insumo directo para evaluación académica formal.