\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<Direction, TrafficLight>})
    \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<Event>} 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}
