Programación Paralela
| Zelidee Güémez Henríquez | 2023-1706 |
| Jesus Elias Diaz Feliz | 2023-1683 |
| Jayfry Manuel Guerrero Váldez | 2023-1107 |
| Gianrobert Ramirez Dominguez | 2023-1743 |
Zelidee Güémez
El proyecto consiste en el desarrollo de una simulación computacional de un sistema bancario multi-sucursal, diseñado para modelar el funcionamiento paralelo de ventanillas físicas y cajeros automáticos en la atención de clientes. Cada cliente posee una cuenta de ahorro (personal) o corriente (empresarial), y puede realizar operaciones como depósitos, retiros o consultas de saldo.
La aplicación ha sido implementada como un sistema de consola en C#, empleando programación concurrente mediante hilos (threads) para emular la atención simultánea en distintos puntos de servicio. El sistema gestiona recursos compartidos (como colas de clientes y fondos de cada sucursal) y permite comparar distintas estrategias de paralelización, evaluar escalabilidad y medir rendimiento, con el objetivo de optimizar tiempos de atención y uso de recursos.
La atención en entidades financieras es un problema recurrente en la vida real, donde la gestión eficiente de filas y recursos impacta directamente en la satisfacción del cliente y en la productividad de la institución. Modelar este comportamiento mediante programación paralela permite probar estrategias de distribución de carga sin necesidad de implementarlas en un entorno real, reduciendo costos y riesgos. Además, este tipo de simulaciones tiene aplicaciones directas en otros sectores como supermercados, oficinas gubernamentales o centros de servicio al cliente.
Desarrollar una simulación bancaria multi-sucursal con capacidad de atención simultánea, administración de recursos compartidos y análisis de rendimiento, utilizando técnicas de programación paralela en C#.
- Implementar un modelo concurrente que represente ventanillas y cajeros como hilos independientes.
- Diseñar mecanismos seguros para el manejo de datos compartidos (fondos y colas de clientes).
- Analizar y comparar el rendimiento de diferentes estrategias de paralelización (FIFO, prioridad, ventanillas especializadas o mixtas).
- Evaluar la escalabilidad del sistema aumentando recursos y volumen de clientes.
- Obtener métricas cuantitativas de desempeño.
En un banco real, múltiples clientes esperan en filas para ser atendidos en ventanillas o cajeros automáticos. Cada punto de atención funciona de forma simultánea, pero comparte recursos como el fondo de efectivo de la sucursal o la cola de espera. Una mala distribución de estos recursos puede provocar tiempos de espera elevados, congestión en ciertos puntos y baja eficiencia global.
Se recrea el flujo de atención en sucursales bancarias, con múltiples ventanillas y cajeros, procesando transacciones en paralelo.
El modelo puede ser utilizado por bancos u otras instituciones para probar estrategias de distribución de clientes y detectar configuraciones más eficientes antes de aplicarlas en entornos físicos.
El uso de hilos permite simular operaciones concurrentes y medir su impacto en métricas como tiempo promedio de espera y número de transacciones procesadas.
- Cada ventanilla y cajero automático es implementado como un hilo independiente.
- Esto permite que múltiples clientes sean atendidos de forma paralela, emulando el funcionamiento real de un banco donde varios puntos de servicio operan al mismo tiempo.
- Los hilos comparten estructuras como la cola de clientes y el fondo total de la sucursal.
- Se utilizan mecanismos de sincronización para evitar condiciones de carrera al modificar el saldo o gestionar el turno de cada cliente.
Se comparan enfoques:
- FIFO: Atiende clientes en orden de llegada.
- Prioridad: Da preferencia a clientes preferenciales.
- Mixta: Combina FIFO y prioridad, dando un 75% de prioridad a clientes preferenciales. Esto permite evaluar cómo varía el rendimiento según la forma de asignar clientes a recursos.
Esto permite evaluar cómo varía el rendimiento según la forma de asignar clientes a recursos.
- El sistema permite aumentar la cantidad de sucursales, ventanillas y cajeros, así como el volumen de clientes.
- Esto facilita pruebas de carga para medir si el rendimiento se mantiene o mejora al incrementar los hilos disponibles.
- Se registran indicadores como el tiempo promedio de espera por cliente, tiempo promedio de servicio, speedup, eficiencia, transacciones por hora, tasa de éxito y uso promedio de cada punto de atención.
- Estos datos permiten comparaciones objetivas entre estrategias y escenarios.
- El modelo simula con precisión un entorno bancario, replicando dinámicas de atención, colas y gestión de recursos críticos.
- Es adaptable a otros entornos con problemas similares de concurrencia y distribución de carga.
La solución se basa en un modelo orientado a objetos donde cada entidad del sistema se representa mediante clases:
- Cliente: Contiene datos personales, tipo de cuenta, saldo y transacción solicitada.
- Cuenta: Maneja operaciones básicas (depósito, retiro, consulta).
- Sucursal: Administra su fondo total y las colas de clientes (normales y preferenciales).
- Ventanilla y Cajero: Implementan la lógica de atención concurrente.
- Simulador: Orquesta la ejecución, creación de hilos y recopilación de métricas.
- CalculadoraMetricas: Calcula métricas como tiempo de espera, speedup, eficiencia y transacciones por hora.
- Estrategias: Definen cómo se gestionan las colas (FIFO, Prioridad, Mixta).
En carpeta: docs/
- Hilos para cada ventanilla y cajero, gestionados por
ThreadyThreadPool. - Sincronización con
lock,Interlocked,BlockingCollectionyCancellationTokenSourcepara coordinar detención. - Estrategias configurables: FIFO, Prioridad, Mixta.
- Lenguaje: C#
- Concurrencia:
Threads,System.Threading,System.Collections.Concurrent. - Control de versiones: GitHub
- Pruebas: xUnit
Organizada en carpetas /src, /docs, /tests y /metrics para separación de código, documentación, pruebas y resultados.
SimulacionSucursalesBanco/
│
├── /src
│ ├── clases/
│ │ ├── Ventanilla.cs
│ │ ├── Cajero.cs
│ │ ├── Sucursal.cs
│ │ ├── Cuenta.cs
│ │ ├── Cliente.cs
│ │ └── Transaccion.cs
│ ├── Simulador.cs
│ ├── main.cs
│
├── /tests
│ ├── TestCola.cs
│ ├── TestTransacciones.cs
│ ├── TestConcurrencia.cs
│ ├── TestUtils.cs
│ ├── PruebasUnitarias.cs
│
├── /metrics
│ ├── CalculadoraMetricas.cs
│ ├── EstrategiaFIFO.cs
│ ├── EstrategiaMixta.cs
│ ├── EstrategiaPrioridad.cs
│ ├── IEstrategiaAtencion.cs
│
├── /docs
│ ├── especificacion.md
│ ├── manual_usuario.md
│ ├── Diagrama de Componentes.png
| ├── README.md
│ └── diagrama.docx
│
├── Program.cs
├── SimulacionSucursalesBanco.csproj
└── .gitignore
- main.cs: Interfaz de consola para configurar y ejecutar la simulación.
- Simulador.cs: Gestiona hilos, genera clientes con retraso fijo de 10ms y recopila métricas.
- CalculadoraMetricas.cs: Calcula métricas avanzadas (speedup, eficiencia, transacciones/hora).
- Sucursal.cs: Valida fondos y gestiona colas con
BlockingCollection. - Estrategias: Implementan
IEstrategiaAtencionpara FIFO, Prioridad y Mixta (75% prioridad).
lockpara proteger_fondosenSucursal.cs.Interlockedpara contadores de métricas.BlockingCollectionpara colas thread-safe.CancellationTokenSourcepara coordinar detención de hilos.
- Se eligió C# por su manejo robusto de la concurrencia y la facilidad para implementar estructuras seguras.
- Se usó consola para poder centrarse en el modelo lógico y no en la interfaz gráfica, priorizando rendimiento y simplicidad de pruebas.
Ir a: tests/ y docs/
Tareas principales:
- Diseñar y programar las clases
Cliente,Cajero,Simulador,SucursalyVentanilla. - Implementar la lógica de depósitos, retiros y consultas de saldo.
- Garantizar la correcta sincronización del saldo de la sucursal.
Documentos trabajados:
/src/Cliente.cs/src/Cajero.cs/src/Simulador.cs/src/Sucursal.cs/src/Ventanilla.cs
Tareas principales:
- Diseñar y programar las clases
CuentayTransaccion. - Implementar hilos para ventanillas y cajeros.
- Crear y manejar colas de clientes compartidas.
- Controlar la concurrencia en la atención.
Documentos trabajados:
/src/Cuenta.cs/src/Transaccion.cs
Co-Authored-by:
-
/src/Cliente.cs -
/src/Cajero.cs -
/src/Simulador.cs -
/src/Sucursal.cs -
/src/Ventanilla.cs
Tareas principales:
- Programar estrategias de atención: FIFO, prioridad, ventanillas mixtas o especializadas.
- Calcular métricas: tiempo promedio, tasa de éxito y transacciones por hora.
- Implementar funciones para comparar estrategias.
Documentos trabajados:
/src/EstrategiaFIFO.cs/src/EstrategiaPrioridad.cs/metrics/resultados_fifo.txt
Tareas principales:
- Diseñar pruebas unitarias para entidades, concurrencia y estrategias.
- Simular escenarios con diferentes cantidades de clientes y sucursales.
- Documentar hallazgos y mantener actualizado el archivo
README.md. - Manejar el repositorio y los commits del proyecto.
Documentos trabajados:
/tests/TestTransacciones.cs/tests/TestConcurrencia.cs/tests/TestUtils.cs/docs/manual_usuario.md/docs/especificacion.mdreadme.md/src/main.cs
GitHub para manejo de repositorio y tareas por del proyecto por integrante.
- Implementación de concurrencia con hilos y sincronización.
- Diseño de estrategias de atención para optimizar colas.
- Cálculo de métricas avanzadas para evaluar paralelismo.
-
Sincronización y concurrencia
- Problemas para manejar múltiples clientes asignados a varios cajeros en paralelo.
- Requerimiento de implementar colas de espera y evitar condiciones de carrera.
-
Medición de métricas
- Dificultad en definir correctamente las fórmulas de speedup y eficiencia.
- Requiere normalizar tiempos entre ejecución secuencial y ejecución paralela.
-
Diseño modular del proyecto
- Separación clara de pruebas unitarias y simulación real para evitar mezclas de lógica.
- Necesidad de establecer valores por defecto para evitar errores en ejecución.
-
Escalabilidad
- Al aumentar el número de clientes o procesadores, el sistema se vuelve más complejo.
- Se consideró necesario usar estrategias de planificación (FIFO, prioridad, mixta).
-
Optimización de Estrategias:
- Implementar una estrategia adaptativa que ajuste dinámicamente la probabilidad (actualmente 75% en Mixta) según la carga de clientes preferenciales y normales.
-
Mejoras en Escalabilidad:
- Integrar un balanceador de carga para distribuir clientes entre sucursales según la capacidad de cada una, modificando
Simulador.cspara asignar clientes de manera más inteligente. - Usar
Parallel.ForoPLINQen lugar de hilos explícitos para ciertas operaciones (e.g., procesamiento de métricas), reduciendo la sobrecarga de gestión de hilos.
- Integrar un balanceador de carga para distribuir clientes entre sucursales según la capacidad de cada una, modificando
-
Interfaz de Usuario:
- Desarrollar una interfaz gráfica para visualizar métricas en tiempo real (tiempo de espera, transacciones/hora) y permitir configurar parámetros (
main.cs) sin entrada por consola. - Generar gráficos interactivos en
/docspara comparar estrategias visualmente, complementando/metrics/estrategia_*.txt.
- Desarrollar una interfaz gráfica para visualizar métricas en tiempo real (tiempo de espera, transacciones/hora) y permitir configurar parámetros (
-
Pruebas Más Robustas:
- Ampliar
test_multiproceso.cspara incluir pruebas de estrés con cientos de clientes concurrentes. - Añadir pruebas en
test_transacciones.cspara validar transacciones mixtas (depósito + retiro simultáneos) en la misma cuenta.
- Ampliar
-
Microsoft Docs. (2023). "Task Parallel Library (TPL)". Recuperado de: https://docs.microsoft.com/en-us/dotnet/standard/parallel-programming/task-parallel-library-tpl Usado para aprender sobre
Task,ThreadPool, yCancellationTokenSource. -
xUnit. (2023). "Getting Started with xUnit.net". Recuperado de: https://xunit.net/
Usado para configurar pruebas unitarias.
Ir a: docs/manual_usuario.md
Ir a: tests/ y docs/