Progress on evaluation made

diff --git a/dissertation.tex b/dissertation.tex
index 4191ef4a20e6e5e72b92b4d56352b0dc2e09bf71..7ce09b14276fc7bb0c4742c0047f1507293ae9a7 100644 (file)
--- a/dissertation.tex
+++ b/dissertation.tex
@@ -1,6 +1,8 @@
 \documentclass{report}
 
+\usepackage {graphicx}
 \usepackage {url}
+\usepackage {wrapfig}
 
 \begin{document}
 

diff --git a/evaluation.tex b/evaluation.tex
index dbe0d2fe30676d2e78e9b35e88af887f2f8b5815..edc689c803e3235a1b1e471a50bcd54f5ecf9974 100644 (file)
--- a/evaluation.tex
+++ b/evaluation.tex
@@ -1,2 +1,49 @@
 \chapter{Evaluation}
 
+\section{Experiments and Results}
+
+The following experiments were carried out on the simulator with a Gigabit Ethernet network, with trials being done with both MOOSE and Ethernet as the Data Link Layer protocol. In each case UDP packets, encapsulated in IP datagrams are sent on Ethernet frames from the hosts.
+
+\subsection{Inital Trials}
+
+The first section of trials was done on the following network. These were done to check the protocols were performing correctly.
+
+\begin{figure}[h]
+\includegraphics[width=8cm]{simulation-1}
+\end{figure}
+
+In this set of tests, the first sends a packet, and then a second later, the second host replies.
+
+The first test shows that the local packets, i.e. packets which only traverse their local switch. In this case between Host 0 and Host 1. In both the Ethernet and MOOSE case the packet traverse the switch and go to the host correctly. In the MOOSE case, the address is rewritten in both directions. This provides evidence that the switches are working correctly with the respect to the protocol descriptions.
+
+Further evidence is provided in the second test, where a remote packet, i.e. a datagram which travels to a different switch, is shown. In this case, between Host 0 and Host  Here we have evidence that the addressing and routing between switches is performing correctly and that the switch addressing is working correctly in the case of MOOSE.
+
+Evidence of the effect of the different routing systems can be found in the third test, where Host 4 sends a packet to Host 6. In the case of Ethernet, this is forced to travel via Switch 2, Switch 0, Switch 1 and then Switch 3, before arriving at Host 6, and the reverse for 6 to 4. In the case of MOOSE however, it travels from Host 4, to Switch 2 then Switch 3 then Host 6, and the reverse for 6 to 4. For the unicast packet this results in a large increase in the number of Ethernet datagrams required.
+
+\subsection{Efficency of Routing}
+
+In this test, we are looking at the efficency of the routing protocol.
+
+An extreme example of this, is the effect of the routing protocol on the number of switches each datagram passes through - the more inefficent the routing protocol, the more Ethernet datagrams that are required.
+
+\begin{figure}
+\includegraphics[width=12cm]{simulation-4}
+\end{figure}
+
+\begin{figure}
+\includegraphics[width=2cm]{simulation-4-tree}
+\end{figure}
+
+Here we have a ring network topology. I have also designed it such that the Ethernet protocol choses a spanning tree such that the datagram is required to cross the entire structure to reach the destination. As such, here the Ethernet protocol performs badly, requiring far more frames to reach the other host, whereas MOOSE simply crosses the short distance between the two hosts.
+
+\subsection{State Table Size}
+
+\section{Limitations}
+
+\section{Possible Improvements}
+
+\section{Ethernet}
+
+\section{MOOSE}
+
+

diff --git a/simulation-1.dot b/simulation-1.dot
new file mode 100644 (file)
index 0000000..1e04574
--- /dev/null
+++ b/simulation-1.dot
@@ -0,0 +1,34 @@
+graph G {
+
+       node [shape=box, style=filled];
+       S0 [ pos="2,2" ];
+       S1 [ pos="5,2" ];
+       S2 [ pos="2,5" ];
+       S3 [ pos="5,5" ];
+
+       node [shape=circle, style=filled];
+       H0;
+       H1;
+       H2;
+       H3;
+
+       edge [len=1];
+
+       H0 -- S0;
+       H1 -- S0;
+       H2 -- S1;
+       H3 -- S1;
+       H4 -- S2;
+       H5 -- S2;
+       H6 -- S3;
+       H7 -- S3;
+
+       edge [len=2];
+
+       S0 -- S1;
+       S0 -- S2;
+       S1 -- S3;
+       S2 -- S3;
+
+}
+

diff --git a/simulation-4-tree.dot b/simulation-4-tree.dot
new file mode 100644 (file)
index 0000000..acb423f
--- /dev/null
+++ b/simulation-4-tree.dot
@@ -0,0 +1,48 @@
+graph G {
+
+       node [shape=box, style=filled];
+       S0; S1; S2; S3; S4;
+       S5; S6; S7; S8; S9;
+       S10; S11; S12; S13;
+       S14; S15; S16; S17;
+       S18; S19; S20; S21;
+       S22; S23; S24;
+
+       node [shape=circle, style=filled];
+       H0; H1;
+
+       edge [len=1];
+
+       S12 -- H0;
+       S13 -- H1;
+
+       edge [len=2];
+
+       S0 -- S1;
+       S1 -- S2;
+       S2 -- S3;
+       S3 -- S4;
+       S4 -- S5;
+       S5 -- S6;
+       S6 -- S7;
+       S7 -- S8;
+       S8 -- S9;
+       S9 -- S10;
+       S10 -- S11;
+       S11 -- S12;
+//     S12 -- S13;
+       S14 -- S13;
+       S15 -- S14;
+       S16 -- S15;
+       S17 -- S16;
+       S18 -- S17;
+       S19 -- S18;
+       S20 -- S19;
+       S21 -- S20;
+       S22 -- S21;
+       S23 -- S22;
+       S24 -- S23;
+       S0  -- S24;
+
+}
+

diff --git a/simulation-4.dot b/simulation-4.dot
new file mode 100644 (file)
index 0000000..1bca1c5
--- /dev/null
+++ b/simulation-4.dot
@@ -0,0 +1,48 @@
+graph G {
+
+       node [shape=box, style=filled];
+       S0; S1; S2; S3; S4;
+       S5; S6; S7; S8; S9;
+       S10; S11; S12; S13;
+       S14; S15; S16; S17;
+       S18; S19; S20; S21;
+       S22; S23; S24;
+
+       node [shape=circle, style=filled];
+       H0; H1;
+
+       edge [len=1];
+
+       H0 -- S12;
+       H1 -- S13;
+
+       edge [len=2];
+
+       S0 -- S1;
+       S1 -- S2;
+       S2 -- S3;
+       S3 -- S4;
+       S4 -- S5;
+       S5 -- S6;
+       S6 -- S7;
+       S7 -- S8;
+       S8 -- S9;
+       S9 -- S10;
+       S10 -- S11;
+       S11 -- S12;
+       S12 -- S13;
+       S13 -- S14;
+       S14 -- S15;
+       S15 -- S16;
+       S16 -- S17;
+       S17 -- S18;
+       S18 -- S19;
+       S19 -- S20;
+       S20 -- S21;
+       S21 -- S22;
+       S22 -- S23;
+       S23 -- S24;
+       S24 -- S0;
+
+}
+