mirror of
https://github.com/davidalves04/Trabalho-Pratico-SD.git
synced 2025-12-08 20:43:32 +00:00
docs: remove final report and ignore LaTeX files.
This commit is contained in:
1
.gitignore
vendored
1
.gitignore
vendored
@@ -6,6 +6,7 @@
|
|||||||
*.trace
|
*.trace
|
||||||
logs
|
logs
|
||||||
*.md
|
*.md
|
||||||
|
*.tex
|
||||||
|
|
||||||
# BlueJ files
|
# BlueJ files
|
||||||
*.ctxt
|
*.ctxt
|
||||||
|
|||||||
@@ -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<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}
|
|
||||||
Reference in New Issue
Block a user