CS4226 Computer Architecture
Module information #
CS4226 Internet Architecture at the National University of Singapore (NUS) is a module that teaches us about the Internet and how it works.
For AY22/23 Sem 1, the module is taught by Prof. Ma Tianbai, Richard.
This is only offered in Semester 1
- Lecture: Friday, 1200-1400
- Tutorial: Friday, 1400-1500 (Week 3 to 13)
- Venue: LT15
Module Breakdown #
- Written Assignment 10%
- 2 Programming Assignments 30%
- Mid-term Exam 20%
- Final Exam 40%
- CS2105 or EE3204/E or EE4204
- EE2012/A or MA2216 or ST2131 or ST2334
Module Details #
This module focuses on advanced networking concepts and technologies.
It covers the following topics:
- Network Architectures
- Internet Ecosystem
- Inter-Domain routing: BGP
- Business and Economics
- Network Management Paradigm
- Software-Defined Networking (SDN)
- Network Performance
- Queuing model and analysis
- Resource allocation
|1||Logistics + Performance|
|4||Software Defined Networking|
|7||Border Gateway Protocol (BGP)|
|8||Peer to Peer|
For the first half of the semester, from Performance to Resource Allocation, the lecture content was very math heavy. As a not-very-math guy, some additional effort is required to understand the concepts involved.
The second half of the semester was more interesting as it covered more practical topics such as SDN and network performance. There are also some overlap with CS3103.
Professor Richard is a very good lecturer who understands the material well. He tries to make the class interactive by asking the crowd questions and getting them to answer.
The topics that he focuses on will be tested more thoroughly in exams.
The class is taught in hybrid mode with both in-person and online lectures. Students can choose to attend either.
The professor does not put everything in the slides, so some note taking is required from our side.
Writing notes while listening in lectures is a good way to learn the material and prepare for exams.
The topics for the tutorial are as follows:
- Probability + Little’s Law
- Poisson Process + M/M/1
- Queuing Theory
- Resource Allocation
- Mininet + ONOS (For the assignment)
For tutorials 1 to 4, it is quite heavy on the math side. With some hard work and practice, it should be relatively understandable.
For tutorial 5, it is mainly a walk-through on how to do the tutorial. There is a Virtual Machine (VM) image provided which we have to use for the assignment. This will be further elaborated within the assignment section of the review.
Written Assignment #
The written assignment involved a sample midterms paper which we are required to complete.
We will receive full credit if we complete the paper and submit a survey to describe how hard the sample paper was when we were trying to complete it.
The written assignment is similar in difficulty of the midterms paper (including the voided question).
Assignment 1: Setting up a SDN #
For the 1st assignment, we were tasked to set up a SDN network using ONOS and Openflow.
There are 3 different parts to this assignment:
- Building a Virtual Network (5 Marks)
- Traditional Learning Switch (8 Marks)
- Intent-based Learning Switch (7 Marks)
Part 1: Building a Virtual Network #
For this section, we have to make use of mininet to create a virtual network. We have to create a topology with N hosts, M switches and L links.
They are given as an input file. We have to parse the file and run the commands to create the network.
One thing to note is to take a look at the API documentation before starting on the assignment.
Sometimes the code in the file may fail silently and the network does not run as expected.
Part 2: Traditional Learning Switch #
For this section, we have 2 subtasks.
- Implement a learning switch (5 Marks)
- Firewall (3 Marks)
For the section 1, we have to implement a learning switch based on the ONOS API.
For the second section, we have to implement a command within ONOS that allows a firewall to be set up between 2 different hosts.
Part 3: Intent-based Learning Switch #
For the last section, we have to implement an intent-based learning switch. This was pretty cool section.
Usually in a normal switch configuration, we try to avoid loops within the network. However, with an intent-based learning switch, we can allow loops to exist within the network.
The switch controller can route the packet despite loops within the system.
This assignment tests us on the implementation of the ONOS API to achieve this.
Although some searching was required, the documentation is present on the ONOS API Website.
Searching and implementing the API with the help of the documentation is a good way to learn how to use the API.
To see the actual source code for ONOS you can refer to their Github Page.
Overall this assignment requires a lot of learning from the side of the user and familiarity with the API of ONOS to implement the assignment.
The hard part is to set up the environment correctly before testing can take place.
I would recommend making a
make file or a
bash script to automate the process of setting up the environment for testing.
Each edit to the files requires recompilation of the binary and adding it into ONOS before starting up the entire system again.
Assignment 2: Configuring BGP using Quagga #
This assignment was given relatively late in the semester around week 13. Similar to the previous assignment, there are 4 different parts.
- Building a virtual network (2 Marks)
- BGP Broadcast (3 Marks)
- Set Metric (2 Marks)
- BGP Community and Local Preference (3 Marks)
We were given a template from a github repository to start off of and edit the code from there. A lot of edits were required on our side as the directories have to be changed to match the ones that we have implemented on our local VM image.
The professor mentioned that this assignment will be relatively easier than the previous assignment. However, I felt that it was the harder one due to some issues with the assignment which will be explained later.
Part 1: Building a Virtual Network #
For the first section, it was very similar to part 1 from assignment 1. However, the code API is slightly different.
We were given a picture with all the hosts, links and switches that we have to configure. Each interface as well as their IP addresses were provided.
We just have to set up the network using the API provided.
It was relatively straightforward and easy to implement. Most of the required code is similar to the examples they have provided and we just have to do some slight modification.
Part 2: BGP Broadcast #
After setting up the virtual network, we have to run BGP within this mini internet topology.
We have to set up the BGP configuration for each of the routers.
bgpd as a daemon and we have to configure the routers to run BGP.
We have to write
bgpd.conf files for each of the routers and set up the configuration for each of the routers.
This required some digging through the examples that were provided by the teaching assistants to find the correct configuration to use.
Part 3: Set Metric #
In this section we have to set our metric for the BGP configuration so that incoming traffic is routed in one direction and outgoing traffic is routed in another direction.
This section is relatively plug and play from the tutorial as well as the configuration they have provided in the github repo.
Part 4: BGP Community and Local Preference #
For the last section we have to set BGP Community and Local Preference for the BGP configuration.
This section is similar to the one we have done in CS3103 where we have to configure the BGP community and local preference for the BGP configuration.
This is also a relatively easier section to implement as the lecture notes have clear outlines on how to implement it. Some fiddling is required to test and check if the configuration is correct.
The assignment looked ok on paper. However, there were some issues during the execution of it.
There were some loops which were found on the VM. This resulted in some hosts being unable to reach another one.
As a result, it became very hard to test if the configuration is working correctly and common commands to test the network (such as
pingall) causes weird errors that required a restart to fix.
However, the TA was very helpful and re-uploaded the assignment PDF to fix and explain the issue. He also extended the deadline so that we will have enough time to update our assignment to match the new requirements which were required for this assignment.
Midterm Exams #
The midterm exams were physical and tested topics from Performance to Resource allocation.
The exam was in the form of a Luminus quiz within the lecture venue and it was open book. We are allowed to bring any notes that we required and refer to them during the exam. As the module had a lot of students, the lecture theatre was very full.
Due to a mistake in one of the questions, it was voided. The voided question also happened to be the hardest questions which might have resulted in a skewed bell curve.
Final Exam #
The final exam was also in the form of a Luminus quiz. However, this time, it is held in UTown.
Even though this is the final exam, the topics from the first half of the semester were also heavily tested. We were allowed to view PDFs for notes provided during the course but we could print out any other materials on paper to refer to them. (Some of the blog posts here were made for that purpose in mind here).
The format of the paper was similar to the past year papers. Grinding the past year papers is a very helpful way to study for the finals.
Lectures: 6/10 (Moderate)
- Requires some revisiting and doing out the examples to understand the concepts clearly especially for the earlier parts
Tutorials: 6/10 (Moderate)
- The tutorials require some references to the lecture notes to figure out
- Doing the tutorials were very good preparation for the midterms and final exams
Assignment 1: 8/10 (Heavy)
- A lot of document references were required to complete the assignment
- A large portion of time was spent on setting up everything in the environment to make it work correctly
- This may be due to the fact that I don’t really understand what was going on during the tutorial where they went through the set up
Assignment 2: 6/10 (Moderate)
- This assignment was less workload compared to assignment 1
- A lot of references were still required to complete the assignment
- The experience from the previous assignment is also helpful for this assignment
Overall: 6.5/10 (Moderate)
- Lectures: 9/10
- The lectures were well organized and the slides were very clear with examples.
- Not everything is provided in the slides so some note taking is required on our side when the professor is explaining the concept.
- Tutorials 7/10
- The first half of the tutorials were very well organized and the slides were very clear.
- However, for the second half, it seems a little confusing on the lab set up.
- Assignment 1: 7/10
- This is the first iteration of the assignment as it was just switched to ONOS.
- Assignment 2: 6.5/10
- There were some mistakes in the assignment PDF initially which created a lot of confusion.
- However, the TA managed to rectify it and extend the deadline.
- Overall: 7.375/10
- Lectures: 8/10
- The lectures were pretty well explained
- Tutorials: 6/10
- During the lecture I felt that the TA’s explanation was a little confusing
- Some self review is required after the tutorial to understand the concepts better
- Assignment 1: 7/10
- We did learn on how the underlying implementation work for ONOS
- We also managed to have some hands on experience with ONOS
- Assignment 2: 6/10
- The assignment was pretty straightforward and we just have to follow the tutorial.
- After setting up the settings for the first few routers, the rest were relatively similar and only required some minor tweaks
- Overall: 6.75/10
- Lectures: 7/10
- I did not enjoy the initial lectures as I was bad at statistics
- However, the second half of the semester was a lot more interesting as we were learning about how the network is applied and more practical aspects of it
- Tutorials: 3/10
- I did not enjoy the tutorial sessions
- Could not really understand some of the concepts
- Was confused during most of the setup lab sessions
- Assignment 1: 3/10
- Feels like flipping through the API and trying to find the relevant API to use
- Assignment 2: 3/10
- Did not enjoy it as much as there were some errors present in the assignment that resulting in the inability to test the code fully.
- Overall: 4/10
- Lectures: 6/10
- The content were more relatable towards the end of the lecture
- The first half of the semester was geared more towards those who want to research on queues and network statistics
- Tutorials: 5/10
- Similar to the lectures, the first half of the semester was more on theoretical items
- For the second half of the semester, most of the tutorials were spent showing examples of how to run the code for the assignment and some examples to guide us in the assignments.
- Assignment 1: 7/10
- The assignment shows us how to implement APIs in ONOS
- Shows us the potential of SDNs and how they revolutionize the networking industry
- Assignment 2: 6/10
- The assignment gives us some hands on experience on network configurations on SDNs
- Overall: 6/10
Overall, I feel that the module taught me a lot about networking and some real life examples on how it is used.
I gained a deeper understanding of the internet and have learnt to appreciate it more. However, I feel that this module is not for me personally. Maybe others taking the module enjoyed it more than I have.
I would recommend this module for anyone who is:
- Interested in taking further networking mods as this is a prerequisite
- Interested in the theoretical side of networking
- Wants to learn more about Software Defined networks
Expected Grade: B+/A-
- Did pretty well for the midterms
- Did ok for the finals but not sure about the bell curve.
Actual Grade: B+ (To be updated)
Helpful links #
From this blog #
- Software Defined Networks
- Internet Interconnection
- Border Gateway Protocol
- Peer to Peer Networking
- Distributed Hash Tables