diff --git a/.gitignore b/.gitignore index 9d01a52..06a5efd 100644 --- a/.gitignore +++ b/.gitignore @@ -6,6 +6,7 @@ *.trace logs *.md +*.tex # BlueJ files *.ctxt diff --git a/RELATORIO_FINAL.tex b/RELATORIO_FINAL.tex deleted file mode 100644 index ee4437b..0000000 --- a/RELATORIO_FINAL.tex +++ /dev/null @@ -1,712 +0,0 @@ -\documentclass[12pt,a4paper]{article} - -% Pacotes essenciais -\usepackage[utf8]{inputenc} -\usepackage[portuguese]{babel} -\usepackage[T1]{fontenc} -\usepackage{graphicx} -\usepackage{hyperref} -\usepackage{booktabs} -\usepackage{longtable} -\usepackage{geometry} -\usepackage{fancyhdr} -\usepackage{amsmath} -\usepackage{listings} -\usepackage{xcolor} -\usepackage{float} -\usepackage{caption} -\usepackage{subcaption} - -% Configuração da página -\geometry{ - left=2.5cm, - right=2.5cm, - top=2.5cm, - bottom=2.5cm -} - -% Configuração de hyperlinks -\hypersetup{ - colorlinks=true, - linkcolor=blue, - filecolor=magenta, - urlcolor=cyan, - pdftitle={Trabalho Prático - Sistemas Distribuídos}, - pdfauthor={David Alves, Leandro Afonso, Gabriel Moreira}, -} - -% Configuração de código -\lstset{ - basicstyle=\ttfamily\footnotesize, - breaklines=true, - frame=single, - numbers=left, - numberstyle=\tiny, - keywordstyle=\color{blue}, - commentstyle=\color{green!60!black}, - stringstyle=\color{red} -} - -% Cabeçalho e rodapé -\pagestyle{fancy} -\fancyhf{} -\rhead{Sistemas Distribuídos} -\lhead{Trabalho Prático} -\rfoot{Página \thepage} - -\begin{document} - -% ============================================================ -% PÁGINA DE TÍTULO -% ============================================================ -\begin{titlepage} - \centering - \vspace*{2cm} - - {\LARGE\bfseries Licenciatura em Segurança Informática\\e Redes de Computadores\par} - \vspace{1.5cm} - - {\Large Unidade Curricular ``Sistemas Distribuídos''\par} - \vspace{0.5cm} - {\large Ano letivo 2024/2025\par} - \vspace{2cm} - - {\huge\bfseries Trabalho Prático\par} - \vspace{0.5cm} - {\Large Simulação de Tráfego Urbano Distribuído\par} - \vspace{2cm} - - {\large\bfseries Realizado por:\par} - \vspace{0.5cm} - {\large - David Alves, número de aluno 8240231\\ - Leandro Afonso, número de aluno [A COMPLETAR]\\ - Gabriel Moreira, número de aluno [A COMPLETAR] - \par} - \vspace{1.5cm} - - {\large\bfseries Docente da UC:\par} - \vspace{0.3cm} - {\large Ronaldo Moreira Salles\par} - - \vfill - - {\large 8 de dezembro de 2024\par} -\end{titlepage} - -% ============================================================ -% ÍNDICE -% ============================================================ -\tableofcontents -\newpage - -% ============================================================ -% INTRODUÇÃO -% ============================================================ -\section{Introdução} - -O presente trabalho tem como objetivo dotar os alunos com a capacidade de desenvolver uma aplicação distribuída em linguagem Java, simulando um sistema de tráfego urbano. O projeto é desenvolvido de modo a permitir avaliar e gerir as regras de controlo dos semáforos, tendo em conta diferentes cargas de tráfego. - -A simulação implementa uma arquitetura de processos distribuídos que comunicam através de sockets TCP/IP, onde cada componente opera de forma autónoma enquanto contribui para o comportamento global do sistema. Este paradigma permite avaliar propriedades como escalabilidade, tolerância a falhas e sincronização distribuída em ambientes concorrentes. - -% ============================================================ -% O MODELO DE SIMULAÇÃO -% ============================================================ -\section{O Modelo de Simulação} - -O sistema retrata uma malha três por três, tendo três pontos de entrada (E1, E2 e E3), cinco cruzamentos (de Cr1 a Cr5) e um ponto de saída (S). As arestas representam as ruas e podem ser de sentido único ou duplo. Cada cruzamento é um processo separado, responsável pela gestão local do tráfego através de semáforos independentes que controlam três direções (Sul, Este e Oeste). O ponto de saída recolhe as estatísticas finais dos veículos que terminam o seu percurso. - -\subsection{Geração de Veículos} - -O processo coordenador (\texttt{CoordinatorProcess}) atua como o gerador de veículos, colocando-os no percurso através dos pontos de entrada seguindo o modelo de \textbf{Poisson} ($\lambda$ configurável). A simulação modela assim a chegada de veículos de forma realista, semelhante ao tráfego real. Esta abordagem significa que o número total de veículos gerados varia entre execuções. Como alternativa, o sistema permite também configurar um modelo de chegadas fixas, onde os veículos chegam em intervalos constantes e previsíveis. - -\subsection{Características dos Veículos} - -Cada veículo criado tem a probabilidade de ser: -\begin{itemize} - \item \textbf{Mota} (20\%): Tempo de travessia = $0.5 \times$ tempo base - \item \textbf{Carro} (60\%): Tempo de travessia = $1.0 \times$ tempo base - \item \textbf{Camião} (20\%): Tempo de travessia = $2.0 \times$ tempo base -\end{itemize} - -Cada veículo possui um identificador único e uma rota predefinida que determina o seu percurso completo até ao nó de saída. As rotas são atribuídas segundo a política de encaminhamento configurada: -\begin{itemize} - \item \textbf{Random}: Escolha aleatória entre todas as rotas possíveis - \item \textbf{Shortest Path}: Seleção da rota com menor número de saltos - \item \textbf{Least Congested}: Escolha da rota com menor congestionamento atual -\end{itemize} - -\subsection{Modelo de Eventos Discretos (DES)} - -A simulação baseia-se num modelo de eventos discretos, onde cada cruzamento mantém uma fila de prioridade de eventos ordenados cronologicamente por timestamp. Os eventos incluem: -\begin{itemize} - \item Chegadas e partidas de veículos - \item Mudanças de estado dos semáforos - \item Atualizações de estatísticas -\end{itemize} - -Cada semáforo opera como uma thread independente, alternando entre os estados \textbf{GREEN} (verde) e \textbf{RED} (vermelho), gerindo uma fila FIFO de veículos que aguardam passagem. Quando um veículo atravessa um cruzamento, é enviado para o processo do próximo cruzamento indicado na sua rota, onde é adicionado à fila do semáforo correspondente à direção necessária. - -\subsection{Comunicação Distribuída} - -A arquitetura distribuída permite que cada componente seja executado de forma independente. As comunicações são baseadas em sockets TCP/IP, com serialização das mensagens em JSON através da biblioteca \textbf{Gson}. Esta abordagem garante interoperabilidade e facilita a depuração do sistema. - -% ============================================================ -% ARQUITETURA DO SISTEMA E COMPONENTES -% ============================================================ -\section{Arquitetura do Sistema e Componentes} - -Foi desenvolvido um diagrama que retrata a arquitetura do projeto, ilustrando a topologia da rede viária e as conexões entre os diversos processos. - -\subsection{Componentes Principais} - -\subsubsection{Coordenador (\texttt{CoordinatorProcess})} -\begin{itemize} - \item \textbf{Porta}: Coordenação central sem socket servidor próprio (atua como cliente) - \item \textbf{Função}: Geração de veículos, gestão do relógio global de simulação, injeção de carga nos pontos de entrada - \item \textbf{Responsabilidades}: - \begin{itemize} - \item Implementação do modelo de Poisson para chegadas estocásticas - \item Seleção de rotas baseada na política configurada - \item Sincronização temporal da simulação - \end{itemize} -\end{itemize} - -\subsubsection{Processos de Cruzamento (\texttt{IntersectionProcess})} - -Cada cruzamento mantém um \texttt{ServerSocket} dedicado que aceita ligações de múltiplos clientes simultaneamente, criando uma thread para cada ligação estabelecida: - -\begin{itemize} - \item \textbf{Cr1}: Porta 8001 - \item \textbf{Cr2}: Porta 8002 - \item \textbf{Cr3}: Porta 8003 - \item \textbf{Cr4}: Porta 8004 - \item \textbf{Cr5}: Porta 8005 -\end{itemize} - -\textbf{Responsabilidades}: -\begin{itemize} - \item Gestão local de semáforos (3 direções: Sul, Este, Oeste) - \item Processamento de eventos DES locais - \item Encaminhamento de veículos para o próximo destino - \item Reporte periódico de estatísticas ao Dashboard -\end{itemize} - -\subsubsection{Nó de Saída (\texttt{ExitNodeProcess})} -\begin{itemize} - \item \textbf{Porta}: 9001 - \item \textbf{Função}: Agregação final de métricas - \item \textbf{Responsabilidades}: - \begin{itemize} - \item Cálculo do tempo total de permanência no sistema - \item Throughput global - \item Estatísticas agregadas por tipo de veículo - \end{itemize} -\end{itemize} - -\subsubsection{Servidor de Dashboard (\texttt{DashboardServer})} -\begin{itemize} - \item \textbf{Porta}: 9000 - \item \textbf{Função}: Monitorização centralizada e visualização em tempo real - \item \textbf{Responsabilidades}: - \begin{itemize} - \item Agregação de estatísticas de todos os processos - \item Deteção de falhas através de heartbeats - \item Renderização da interface gráfica (JavaFX) ou CLI - \end{itemize} -\end{itemize} - -\subsection{Sincronização e Concorrência} - -O \texttt{DashboardServer} implementa um sistema de agregação com \textbf{10 threads concorrentes} (thread pool) que processam atualizações de estatísticas vindas dos cinco cruzamentos. Utiliza um \texttt{ConcurrentHashMap} para armazenar métricas por cruzamento, permitindo leituras simultâneas enquanto recebe atualizações. O frontend é atualizado a cada \textbf{5 segundos}. - -A sincronização entre os processos ocorre através de \textbf{comunicação assíncrona}, onde cada processo continua a sua execução local enquanto envia e recebe mensagens. Os semáforos dentro de cada cruzamento operam de forma autónoma com ciclos independentes. O dashboard identifica a ausência de heartbeats para detetar falhas de processos. - -% ============================================================ -% CLASSES E MÉTODOS -% ============================================================ -\section{Classes e Métodos} - -O programa está organizado em diversos packages que contêm classes com responsabilidades distintas. Neste relatório são mencionadas as principais que sustentam o projeto, estando o resto da documentação apoiado em JavaDoc. - -\subsection{Package \texttt{sd.model}} - -\subsubsection{Classe \texttt{Vehicle}} -Representa cada veículo na simulação com os seguintes atributos: -\begin{itemize} - \item \texttt{vehicleId}: Identificador único - \item \texttt{vehicleType}: Tipo (MOTORCYCLE, CAR, TRUCK) - \item \texttt{entryTime}: Timestamp de entrada no sistema - \item \texttt{route}: Lista de nós que compõem o percurso completo -\end{itemize} - -\textbf{Métodos principais:} -\begin{itemize} - \item \texttt{advanceRoute()}: Avança para o próximo nó na rota - \item \texttt{getCurrentDestination()}: Obtém o próximo cruzamento - \item \texttt{addWaitingTime(double time)}: Acumula tempo de espera em filas - \item \texttt{addCrossingTime(double time)}: Acumula tempo de travessia -\end{itemize} - -\subsubsection{Classe \texttt{Intersection}} -Gere os cruzamentos, mantendo: -\begin{itemize} - \item Um mapa de semáforos por direção (\texttt{Map}) - \item Uma tabela de encaminhamento que mapeia destinos para direções específicas -\end{itemize} - -\textbf{Métodos principais:} -\begin{itemize} - \item \texttt{configureRoute(String destination, Direction direction)}: Define a tabela de routing - \item \texttt{receiveVehicle(Vehicle vehicle)}: Recebe veículos e coloca-os na fila do semáforo correspondente - \item \texttt{getTrafficLight(Direction direction)}: Obtém o semáforo de uma direção específica -\end{itemize} - -\subsubsection{Classe \texttt{TrafficLight}} -Controla cada semáforo individualmente, utilizando locks (\texttt{ReentrantLock}) para garantir thread-safety. - -\textbf{Métodos principais:} -\begin{itemize} - \item \texttt{addVehicle(Vehicle vehicle)}: Adiciona veículo à fila (FIFO) - \item \texttt{removeVehicle()}: Remove veículo da fila (apenas quando verde) - \item \texttt{changeState(TrafficLightState newState)}: Alterna entre GREEN e RED - \item \texttt{getQueueSize()}: Retorna o tamanho atual da fila -\end{itemize} - -\subsubsection{Classe \texttt{Event} (no package \texttt{sd.des})} -Representa eventos discretos na simulação. Implementa \texttt{Comparable} para ordenação automática cronológica na fila de prioridade. - -\textbf{Atributos:} -\begin{itemize} - \item \texttt{timestamp}: Momento em que o evento deve ocorrer - \item \texttt{eventType}: Tipo do evento (VEHICLE\_ARRIVAL, TRAFFIC\_LIGHT\_CHANGE, etc.) - \item \texttt{associatedData}: Payload específico do evento -\end{itemize} - -\subsubsection{Classe \texttt{Message}} -Define a estrutura das mensagens trocadas entre processos. - -\textbf{Atributos:} -\begin{itemize} - \item \texttt{messageId}: Identificador único da mensagem - \item \texttt{messageType}: Tipo da mensagem (VEHICLE\_TRANSFER, STATS\_UPDATE, etc.) - \item \texttt{sourceNode}: Nó de origem - \item \texttt{destinationNode}: Nó de destino - \item \texttt{payload}: Conteúdo serializado em JSON -\end{itemize} - -\subsection{Package \texttt{sd.coordinator}} - -\subsubsection{Classe \texttt{CoordinatorProcess}} -Conduz a simulação através do paradigma de eventos discretos distribuído. - -\textbf{Responsabilidades:} -\begin{itemize} - \item Inicialização da topologia da rede - \item Geração de veículos segundo distribuição de Poisson - \item Injeção de carga nos pontos de entrada (E1, E2, E3) - \item Seleção de rotas com base na política configurada -\end{itemize} - -\textbf{Métodos principais:} -\begin{itemize} - \item \texttt{initialize()}: Prepara o sistema, estabelece conexões com interseções - \item \texttt{run()}: Loop principal de geração de veículos - \item \texttt{generateAndInjectVehicle()}: Cria um novo veículo e injeta-o num ponto de entrada - \item \texttt{selectRouteForVehicle()}: Determina a rota com base na política ativa -\end{itemize} - -\subsubsection{Classe \texttt{SocketClient}} -Facilita a comunicação de rede do lado do cliente. - -\textbf{Métodos principais:} -\begin{itemize} - \item \texttt{connect(String host, int port)}: Estabelece ligação TCP - \item \texttt{send(Message message)}: Serializa e transmite mensagem - \item \texttt{close()}: Encerra ligação e liberta recursos -\end{itemize} - -\subsection{Package \texttt{sd}} - -\subsubsection{Classe \texttt{IntersectionProcess}} -Representa um nó de processamento autónomo (Worker Node) na malha distribuída. - -\textbf{Arquitetura híbrida:} -\begin{itemize} - \item \textbf{Reativa (Network I/O)}: Threads dedicadas aceitam conexões TCP e injetam veículos nas filas - \item \textbf{Proativa (DES Engine)}: Thread de processamento de eventos gere a lógica temporal -\end{itemize} - -\textbf{Métodos principais:} -\begin{itemize} - \item \texttt{initialize()}: Carrega configurações, cria semáforos e rotas - \item \texttt{startTrafficLightThreads()}: Inicia threads de controlo dos semáforos - \item \texttt{startServerSocket()}: Aceita conexões de veículos de outros processos - \item \texttt{sendVehicleToNextDestination(Vehicle vehicle)}: Encaminha veículos pela rede - \item \texttt{reportStatistics()}: Envia métricas ao Dashboard periodicamente - \item \texttt{shutdown()}: Encerra serviços e liberta recursos -\end{itemize} - -\subsection{Package \texttt{sd.util}} - -\subsubsection{Classe \texttt{VehicleGenerator}} -Responsável pela criação de veículos segundo o modelo de Poisson. - -\textbf{Métodos principais:} -\begin{itemize} - \item \texttt{generateVehicle()}: Cria veículo com tipo e rota selecionados aleatoriamente - \item \texttt{getNextArrivalTime(double lambda)}: Calcula o momento da próxima chegada usando distribuição exponencial -\end{itemize} - -\subsubsection{Classe \texttt{StatisticsCollector}} -Agrega métricas do sistema, rastreando veículos em trânsito e mantendo contadores globais. - -\textbf{Métodos principais:} -\begin{itemize} - \item \texttt{recordVehicleGeneration(Vehicle vehicle)}: Regista criação de veículo - \item \texttt{recordVehicleArrival(Vehicle vehicle, String intersection)}: Regista chegada a cruzamento - \item \texttt{recordVehicleDeparture(Vehicle vehicle, String intersection)}: Regista partida de cruzamento - \item \texttt{recordVehicleCompletion(Vehicle vehicle)}: Regista conclusão do percurso - \item \texttt{getStatistics()}: Retorna snapshot das métricas atuais - \item \texttt{printStatistics()}: Gera relatórios com throughput, tempos médios, etc. -\end{itemize} - -\subsection{Package \texttt{sd.config}} - -\subsubsection{Classe \texttt{SimulationConfig}} -Carrega parâmetros do ficheiro \texttt{simulation.properties} (ou variantes \texttt{simulation-low.properties}, \texttt{simulation-medium.properties}, \texttt{simulation-high.properties}). - -\textbf{Parâmetros configuráveis:} -\begin{itemize} - \item Duração da simulação - \item Taxa de chegada $\lambda$ (lambda) - \item Probabilidades de tipos de veículos - \item Tempos de travessia base - \item Tempos de ciclo dos semáforos - \item Política de encaminhamento -\end{itemize} - -\subsection{Package \texttt{sd.routing}} - -\subsubsection{Políticas de Encaminhamento} -O sistema suporta três estratégias de seleção de rotas: - -\begin{itemize} - \item \texttt{RandomRouteSelector}: Escolha equiprovável entre todas as rotas disponíveis. - \item \texttt{ShortestPathRouteSelector}: Seleção da rota com menor número de saltos (hops). - \item \texttt{LeastCongestedRouteSelector}: Escolha da rota com menor congestionamento atual, baseada em feedback dos cruzamentos sobre tamanhos de filas. -\end{itemize} - -% ============================================================ -% AVALIAÇÃO DO DESEMPENHO DO SISTEMA -% ============================================================ -\section{Avaliação do Desempenho do Sistema} - -A avaliação do sistema baseia-se em métricas recolhidas pela classe \texttt{DashboardStatistics}, que monitoriza: -\begin{itemize} - \item Número de veículos gerados - \item Número de veículos que completaram o percurso - \item Taxa de conclusão (\%) - \item Tempo médio no sistema (segundos) - \item Tempo médio de espera acumulado em filas (segundos) - \item Throughput (veículos/segundo) -\end{itemize} - -\subsection{Cenários de Carga} - -Foram configurados três cenários de carga de tráfego, cada um executado 5 vezes para obter estatísticas fiáveis. - -\subsubsection{Tráfego Leve (LOW LOAD)} -\textbf{Configuração:} \texttt{simulation-low.properties} - $\lambda = 0.2$ veículos/segundo - -\begin{table}[H] -\centering -\caption{Métricas de Desempenho - Tráfego Leve} -\begin{tabular}{lrrrrr} -\toprule -\textbf{Métrica} & \textbf{Média} & \textbf{Desvio Padrão} & \textbf{IC 95\%} & \textbf{Mín} & \textbf{Máx} \\ -\midrule -Veículos Gerados & 364.60 & 9.34 & [351.30, 377.90] & 350 & 373 \\ -Veículos Completados & 219.60 & 31.19 & [175.22, 263.98] & 187 & 263 \\ -Taxa de Conclusão (\%) & \textbf{60.38} & 9.71 & [46.57, 74.20] & 50.40 & 72.85 \\ -Tempo Médio no Sistema (s) & \textbf{33.04} & 7.41 & [22.50, 43.58] & 23.36 & 42.28 \\ -Tempo Médio de Espera (s) & 13.78 & 3.43 & [8.82, 18.73] & 9.72 & 17.53 \\ -\bottomrule -\end{tabular} -\end{table} - -\textbf{Análise:} Com carga leve, a rede opera abaixo da capacidade sem congestionamento significativo. A taxa de conclusão superior a 60\% e o tempo médio no sistema de apenas 33 segundos demonstram que o sistema consegue processar eficientemente o tráfego quando a chegada de veículos é esparsa. - -\subsubsection{Tráfego Moderado (MEDIUM LOAD)} -\textbf{Configuração:} \texttt{simulation-medium.properties} - $\lambda = 0.5$ veículos/segundo - -\begin{table}[H] -\centering -\caption{Métricas de Desempenho - Tráfego Moderado} -\begin{tabular}{lrrrrr} -\toprule -\textbf{Métrica} & \textbf{Média} & \textbf{Desvio Padrão} & \textbf{IC 95\%} & \textbf{Mín} & \textbf{Máx} \\ -\midrule -Veículos Gerados & 927.20 & 32.48 & [880.97, 973.43] & 886 & 954 \\ -Veículos Completados & 419.40 & 90.64 & [290.42, 548.38] & 312 & 535 \\ -Taxa de Conclusão (\%) & \textbf{45.23} & 9.64 & [31.50, 58.95] & 34.74 & 56.08 \\ -Tempo Médio no Sistema (s) & \textbf{44.48} & 6.81 & [34.79, 54.18] & 35.08 & 52.56 \\ -Tempo Médio de Espera (s) & 21.05 & 4.73 & [13.55, 28.56] & 14.60 & 25.60 \\ -\bottomrule -\end{tabular} -\end{table} - -\textbf{Análise:} Com tráfego moderado, observa-se o início de congestionamento. A taxa de conclusão cai para 45\% e o tempo médio no sistema aumenta 34\% relativamente ao cenário leve. As filas começam a formar-se nos cruzamentos principais (Cr2 e Cr5). - -\subsubsection{Tráfego Intenso (HIGH LOAD)} -\textbf{Configuração:} \texttt{simulation-high.properties} - $\lambda = 1.0$ veículos/segundo - -\begin{table}[H] -\centering -\caption{Métricas de Desempenho - Tráfego Intenso} -\begin{tabular}{lrrrrr} -\toprule -\textbf{Métrica} & \textbf{Média} & \textbf{Desvio Padrão} & \textbf{IC 95\%} & \textbf{Mín} & \textbf{Máx} \\ -\midrule -Veículos Gerados & 1813.80 & 41.93 & [1754.13, 1873.47] & 1782 & 1872 \\ -Veículos Completados & 651.00 & 354.20 & [146.96, 1155.04] & 179 & 953 \\ -Taxa de Conclusão (\%) & \textbf{35.92} & 19.44 & [8.25, 63.58] & 9.70 & 50.91 \\ -Tempo Médio no Sistema (s) & \textbf{60.15} & 6.17 & [51.38, 68.93] & 53.09 & 65.41 \\ -Tempo Médio de Espera (s) & 37.82 & 5.59 & [29.67, 45.96] & 31.51 & 44.58 \\ -\bottomrule -\end{tabular} -\end{table} - -\textbf{Análise:} Com tráfego intenso, a rede aproxima-se da saturação. A taxa de conclusão cai para apenas 36\% com elevada variabilidade ($\sigma = 19.44\%$), indicando comportamento instável. O tempo médio no sistema atinge 60 segundos, mas o aspecto mais crítico é o tempo médio de espera de 37.82 segundos, representando 63\% do tempo total no sistema. A alta variabilidade sugere que o sistema está perto do colapso, com algumas execuções a atingir apenas 9.7\% de taxa de conclusão. - -\subsection{Análise Comparativa} - -\begin{table}[H] -\centering -\caption{Comparação entre Cenários de Carga} -\begin{tabular}{lrrrr} -\toprule -\textbf{Cenário} & \textbf{$\lambda$ (v/s)} & \textbf{Taxa Conclusão (\%)} & \textbf{Tempo Sistema (s)} & \textbf{Tempo Espera (s)} \\ -\midrule -Leve & 0.2 & 60.38 & 33.04 & 13.78 \\ -Moderado & 0.5 & 45.23 & 44.48 & 21.05 \\ -Intenso & 1.0 & 35.92 & 60.15 & 37.82 \\ -\bottomrule -\end{tabular} -\end{table} - -\textbf{Observações:} -\begin{enumerate} - \item \textbf{Relação não-linear}: Dobrar a taxa de chegada ($0.2 \rightarrow 0.5$) reduz a taxa de conclusão em 25\%, mas quadruplicar ($0.2 \rightarrow 1.0$) reduz apenas 40\%, sugerindo efeitos de saturação. - \item \textbf{Gargalos identificados}: Os cruzamentos Cr2 e Cr5 funcionam como pontos de convergência, acumulando os maiores tamanhos de fila. - \item \textbf{Tempo de espera dominante}: Em carga intensa, 63\% do tempo no sistema é gasto em filas. -\end{enumerate} - -\subsection{Otimizações Testadas} - -\subsubsection{Configuração de Ciclos de Semáforos} - -Foram testadas diferentes configurações de temporização: - -\textbf{Ciclos Longos} (verde 60s, vermelho 5s): -\begin{itemize} - \item Maior vazão (throughput) por ciclo - \item Aumento significativo da espera para direções em vermelho - \item Adequado para tráfego unidirecional dominante -\end{itemize} - -\textbf{Ciclos Curtos} (verde 8-10s, vermelho 5s): -\begin{itemize} - \item Distribuição mais equitativa da capacidade - \item Redução da espera máxima - \item Perda de eficiência devido ao overhead de mudanças de estado -\end{itemize} - -\textbf{Ciclos Otimizados} (diferenciados por cruzamento): -\begin{itemize} - \item Cr2 e Cr5: verde 30-40s (pontos de convergência) - \item Cr1, Cr3, Cr4: verde 15-20s (tráfego distribuído) - \item Melhor compromisso entre throughput e equidade -\end{itemize} - -\subsubsection{Políticas de Encaminhamento} - -\textbf{Random}: Baseline - distribuição uniforme da carga mas sem otimização. - -\textbf{Shortest Path}: Minimiza latência individual mas pode criar hotspots nos caminhos mais curtos. - -\textbf{Least Congested}: Balanceamento dinâmico da carga, requer feedback em tempo real dos cruzamentos. Reduz congestionamento mas pode aumentar latência individual ao escolher caminhos mais longos. - -% ============================================================ -% DASHBOARD -% ============================================================ -\section{Dashboard} - -O sistema de monitorização foi implementado utilizando \textbf{JavaFX} para a interface gráfica, fornecendo visualização em tempo real do estado da simulação. - -\subsection{Características Principais} - -\subsubsection{Interface Gráfica} -\textbf{Estatísticas Globais}: Painel superior com métricas agregadas do sistema -\begin{itemize} - \item Veículos gerados vs. completados - \item Taxa de conclusão em tempo real - \item Throughput atual - \item Tempo médio no sistema -\end{itemize} - -\textbf{Tabelas Dinâmicas}: -\begin{itemize} - \item Estatísticas por tipo de veículo (Mota, Carro, Camião) - \item Métricas por interseção (Cr1-Cr5) - \item Tamanhos de fila por direção - \item Estados dos semáforos (cores indicativas) -\end{itemize} - -\textbf{Controlos de Simulação}: -\begin{itemize} - \item Botão \textbf{Start}: Inicia todos os processos distribuídos - \item Botão \textbf{Stop}: Termina a simulação graciosamente - \item Indicador de estado do sistema - \item Heartbeat visual para cada processo -\end{itemize} - -\subsubsection{Arquitetura de Concorrência} - -O \texttt{DashboardServer} utiliza: -\begin{itemize} - \item \textbf{Thread Pool} com 10 threads concorrentes para processar atualizações - \item \texttt{ConcurrentHashMap} para armazenamento thread-safe de métricas - \item \texttt{ScheduledExecutorService} para atualizações periódicas da UI (intervalo de 5 segundos) - \item \texttt{Platform.runLater()} para marshalling seguro de atualizações para a UI thread do JavaFX -\end{itemize} - -\subsubsection{Deteção de Falhas} - -O sistema implementa monitorização de saúde através de: -\begin{itemize} - \item \textbf{Heartbeats}: Cada processo envia sinais periódicos (intervalo configurável) - \item \textbf{Timeout de conexão}: Identifica processos não-responsivos - \item \textbf{Indicadores visuais}: Marcação a vermelho de nós com falhas - \item \textbf{Logs de eventos}: Registo de todas as anomalias detetadas -\end{itemize} - -\subsection{Análise em Batch} - -O sistema inclui uma ferramenta de análise estatística (\texttt{MultiRunAnalyzer}) que: -\begin{itemize} - \item Executa múltiplas simulações automaticamente - \item Calcula médias, medianas, desvios padrão e intervalos de confiança (95\%) - \item Gera relatórios em formato texto e CSV - \item Permite comparação entre diferentes configurações -\end{itemize} - -% ============================================================ -% CONCLUSÃO -% ============================================================ -\section{Conclusão} - -O trabalho desenvolvido demonstra a implementação bem-sucedida de um sistema distribuído para simulação de tráfego urbano, cumprindo os objetivos pedagógicos da unidade curricular. - -\subsection{Principais Conquistas} - -\begin{enumerate} - \item \textbf{Arquitetura Distribuída Robusta}: Implementação de comunicação assíncrona entre processos autónomos através de sockets TCP/IP, com serialização JSON garantindo interoperabilidade. - - \item \textbf{Modelo de Simulação Realista}: Utilização do modelo de eventos discretos (DES) com distribuição de Poisson para chegadas de veículos, aproximando-se de padrões de tráfego reais. - - \item \textbf{Escalabilidade Demonstrada}: O sistema mantém-se funcional desde tráfego leve ($\lambda=0.2$) até tráfego intenso ($\lambda=1.0$), embora com degradação expectável de desempenho em saturação. - - \item \textbf{Monitorização Abrangente}: Dashboard com visualização em tempo real e capacidade de análise estatística multi-execução, permitindo avaliação rigorosa do desempenho. - - \item \textbf{Políticas de Encaminhamento Adaptativas}: Implementação de três estratégias distintas (Random, Shortest Path, Least Congested) demonstrando flexibilidade arquitetural. -\end{enumerate} - -\subsection{Aprendizagens} - -\begin{itemize} - \item \textbf{Sincronização Distribuída}: Gestão da complexidade inerente à coordenação de múltiplos processos autónomos sem relógio global centralizado. - - \item \textbf{Concorrência e Thread-Safety}: Utilização apropriada de locks, estruturas de dados concorrentes e thread pools para garantir correção em ambiente multi-threaded. - - \item \textbf{Trade-offs de Desempenho}: Compreensão das relações não-lineares entre carga de entrada, throughput e latência, especialmente em aproximação à saturação. - - \item \textbf{Análise Quantitativa}: Aplicação de métodos estatísticos (intervalos de confiança, análise de variância) para avaliação rigorosa de sistemas estocásticos. -\end{itemize} - -\subsection{Limitações e Trabalho Futuro} - -\textbf{Limitações identificadas:} -\begin{itemize} - \item Rotas estáticas: Veículos não podem desviar-se em resposta a congestionamento dinâmico - \item Capacidade infinita de filas: Sistema não modela bloqueios físicos por falta de espaço - \item Ausência de prioridades: Todos os veículos são tratados igualmente (sem veículos de emergência) - \item Modelo de semáforos simplificado: Não considera fases de amarelo ou coordenação entre cruzamentos adjacentes -\end{itemize} - -\textbf{Melhorias propostas:} -\begin{enumerate} - \item Implementação de encaminhamento adaptativo baseado em aprendizagem por reforço - \item Modelação de capacidades finitas com backpressure entre cruzamentos - \item Coordenação de semáforos através de ``ondas verdes'' para corredores prioritários - \item Integração de eventos externos (acidentes, obras, eventos especiais) - \item Visualização 3D da malha viária com animação de veículos em movimento -\end{enumerate} - -\subsection{Conclusão Final} - -O projeto cumpre integralmente os requisitos da unidade curricular, demonstrando competências na conceção, implementação e avaliação de sistemas distribuídos. Os resultados quantitativos obtidos através das análises multi-execução fornecem insights valiosos sobre o comportamento do sistema sob diferentes condições de carga, validando a abordagem arquitetural adotada. - -A experiência adquirida na resolução de desafios de sincronização, gestão de concorrência e análise de desempenho constitui uma base sólida para o desenvolvimento de sistemas distribuídos de maior complexidade em contextos profissionais futuros. - -% ============================================================ -% BIBLIOGRAFIA -% ============================================================ -\begin{thebibliography}{9} - -\bibitem{tanenbaum2017} -Tanenbaum, A. S., \& Van Steen, M. (2017). -\textit{Distributed Systems: Principles and Paradigms} (3rd ed.). -Pearson. - -\bibitem{coulouris2011} -Coulouris, G., Dollimore, J., Kindberg, T., \& Blair, G. (2011). -\textit{Distributed Systems: Concepts and Design} (5th ed.). -Addison-Wesley. - -\bibitem{banks2009} -Banks, J., Carson, J. S., Nelson, B. L., \& Nicol, D. M. (2009). -\textit{Discrete-Event System Simulation} (5th ed.). -Pearson. - -\bibitem{oracle2024java} -Oracle. (2024). -\textit{Java Platform, Standard Edition Documentation} (Version 17). -\url{https://docs.oracle.com/en/java/javase/17/} - -\bibitem{goetz2006} -Goetz, B., Peierls, T., Bloch, J., Bowbeer, J., Holmes, D., \& Lea, D. (2006). -\textit{Java Concurrency in Practice}. -Addison-Wesley. - -\bibitem{oracle2024javafx} -Oracle. (2024). -\textit{JavaFX Documentation} (Version 17). -\url{https://openjfx.io/javadoc/17/} - -\bibitem{google2024gson} -Google. (2024). -\textit{Gson User Guide}. -\url{https://github.com/google/gson/blob/master/UserGuide.md} - -\bibitem{law2000} -Law, A. M., \& Kelton, W. D. (2000). -\textit{Simulation Modeling and Analysis} (3rd ed.). -McGraw-Hill. - -\end{thebibliography} - -\vspace{1cm} -\noindent\textbf{Nota:} Este relatório foi elaborado com base na análise do código-fonte do projeto e nos resultados experimentais obtidos através de múltiplas execuções da simulação. Todos os valores estatísticos apresentados foram extraídos dos ficheiros de análise gerados pelo sistema (\texttt{analysis/LOW\_LOAD\_*.txt}, \texttt{analysis/MEDIUM\_LOAD\_*.txt}, \texttt{analysis/HIGH\_LOAD\_*.txt}). - -\end{document}