CS 42200: Computer Networks

Instructor: Vamsi Addanki
Department: Computer Science, Purdue University
Semester: Fall 2026
Location: LWSN 1142
Time: MWF 13:30 - 14:20
Credit hours: 3
Teaching assistants: Youngsuk Kim, Xiao Luo, and Albert Vo
PSOs: HAAS G050
     - Thursday, 15:30 - 16:20: TBA
     - Thursday, 16:30 - 17:20: TBA
     - Wednesday, 10:30 - 11:20: TBA
Office hours: Zoom, requires login/authentication using purdue email
     - TBA: Youngsuk @ Zoom
     - TBA: Xiao @ Zoom
     - TBA: Albert @ Zoom
     - Schedule a meeting by email, Vamsi @ LWSN 2142J or Zoom

List of Topics

Depending on the progress and background of the class, we may spend more time on the first half of the topics (networking basics), and shorten the second half (advanced topics).

  1. Introduction and OSI architecture
  2. Network Latencies, Packet Switching, and Circuit Switching
  3. Application layer, including HTTP and DNS
  4. Transport layer: TCP, UDP, and congestion control
  5. IP layer: Addressing, subnets, NAT, and routing protocols
  6. Multi Commodity Flows: Max flow and Concurrent flow, ECMP and Load balancing
  7. Packet classification
  8. Datacenter Networks Introduction
  9. Network Topologies
  10. DNN Training and Collective Communication
  11. Kernel bypass, and RDMA
  12. Network Buffering
  13. Datacenter Congestion Control
  14. Back to circuit switching: Photonic Interconnects
  15. Wireless Networks (Optional)
  16. Satellite Networks (Optional)

Textbooks and materials

Prerequisites: This course requires background in data structures and algorithms, and programming (c++ and python).

Assignments: Five assignments spread across the semester.

Assignments (Tentative and subject to change)

No lectures or tutorials will be given for the coding and internals of the frameworks involved in the assignments. This is a learning experience for students to explore on their own. LLMs are on your side, but you should understand and know what you are doing ;) We will ask you to explain random pieces of your code during evaluation, primarily “Explain this part of the code” and importantly “Why did you implement the way you did”.

Note: The assignement posted on Brightspace will be the formal description. The following description is informal, just to give you an idea of what to expect.

  1. For each ip address listed here: https://iperf3serverlist.net/, run a ping test and find the min, max, and average round-trip time (rtt). Find the geolocation of the ip address from publicly available data. Do a scatter plot: distance vs rtt. Explain whether and how distance relates to rtt. What do min and max rtt convey about the distance, and the network state?

  2. Write a socket program from scratch using python, that can connect to the iperf3 servers listed in the above website and send data continously. The goal is to measure the throughput i.e., bits/sec that your socket client application is able to send. At regular intervals, extract the tcp socket statistics including snd_cwnd (hint: TCP_INFO_FMT), a corresponding timestamp, round-trip-time (RTT) estimate, and the current throughput bitrate. Run these tests using CUBIC, RENO, and BBR. Identify the regimes in which each algorithm performs better than the others in terms of throughput and RTT, and explain why. Derive a hand-written algorithm that switches between the three congestion control algorithms based on the spontaneous network conditions (cwnd, rtt, packet loss rate, throughput) at any given time instance.

  3. There are two options for the third assignment:
    • [With bonus points] Write a kernel module (or eBPF program) implementing your congestion control algorithm. Test the performance using your socket program, and log throughput values for a 10 second duration. Make sure to select your congestion control algorithm in the socket application. Repeat the same with CUBIC, RENO, and BBR across multiple runs, and compare the throughput values of all four.
    • [No bonus points] Implement your algorithm from assignment 2 in NS-3 within the TCP/IP stack. Evaluate your algorithm in the following setting:
      • Create a leaf-spine topology with 2 ToR switches, 2 Spine switches, and 16 servers connected to each ToR. The server-to-ToR links are 100Gbps, and leaf-to-spine links are 400Gbps. All links have a propagation delay of 500 nanoseconds.
      • From each server, launch one flow towards every other server in the topology. You may use bulksend application in ns3. Set the flowsize to 64MB.
      • Log the flow completion times for each flow
      • Repeat the same with Cubic, TcpNewReno, and BBR
      • Plot the flow completion times (avg and 99th percentile), for your algorithm, CUBIC, RENO, and BBR.
      • Note: Make a choice regarding buffer sizes at each switch. (“Why did you make this design choice?”)

  4. Consider a network with $n$ nodes, each with $d$ incoming and outgoing incident links. Each link has a capacity of unit $1$. Find the topology that maximizes the concurrent flow for a uniform all-to-all traffic matrix ($n\times n$ matrix with all ones, except the diagonal). You may consider formulating it as a linear/integer program and ask a solver (e.g., Gurobi), or comeup with a concrete graph and explanation for why this graph maximizes concurrent flow for all-to-all.

  5. Implement the following algorithms using pytorch gloo backend, and test the algorithms across $n$ machines, each corresponding to one student in the group. You may also need to handle non power-of-two cases depending on your group size. These experiments are easier if the group members are all connected to the same network, preferably a lan.
    • Reduce-scatter: Ring, Recursive doubling, and Swing.
    • Broadcast: Binary tree, and Binomial tree
    • Do one plot for reduce-scatter, and one for broadcast, with x-axis as message sizes (pick a range), and y-axis as the completion time.
    • Bonus: Connect all $n$ machines in a ring, using ethernet cables. Make sure to disconnect the machines from any external network. Setup the LAN, IP addresses, routing etc., such that all $n$ machines are able to ping each other, and have ssh access to each other. Now, run the same experiments as above. You need to demonstrate a functional routing setup, along with at least one run in-person in order to get the bonus.

Grading

Late submission

AI policy

Use of AI tools (e.g., ChatGPT, Copilot, local LLMs, code generators, auto-completion tools) is allowed to the full extent without restrictions, unless explicitly stated otherwise for a specific assignment.

However:

You are responsible for fully understanding, validating, and being able to explain any code, design choices, or analysis produced using AI tools.

During evaluation, you may be asked to explain any part of your submission, including why it was implemented in a particular way.

Submissions that rely on AI-generated content without clear understanding or correctness may receive reduced credit.

You are required to acknowledge the use of AI tools in a brief statement describing how they were used (e.g., debugging, boilerplate generation, conceptual guidance). There is no penalty for making use of AI tools.

The goal is to use AI as a productivity and learning tool, not as a substitute for understanding.

Accommodations

Page 15-16 in the organization slides detail the accommodations available for students with disabilities. Please reach out to the instructor and Purdue’s Disability Resource Center (DRC) for assistance.

Academic integrity

We will default to Purdue’s academic policies throughout this course unless stated otherwise. You are responsible for reading the pages linked below and will be held accountable for their contents.

Honor code

By taking this course, you agree to take the Purdue Honors Pledge: “As a boilermaker pursuing academic excellence, I pledge to be honest and true in all that I do. Accountable together - we are Purdue.”

Acknowledgements

The course material is largely based on the book “Computer Networking: A Top-Down Approach” and the material made available by the authors (sometimes verbatim, the same). The materials also build upon the course “Network Protocols and Architectures” offered at TU Berlin, by Prof. Stefan Schmid. The course page, and policies have been borrowed from the previous iterations of this course by Prof. Muhammad Shahbaz. The lecture content on datacenter networking has been developed by Vamsi Addanki, during the first iteration of CS536 in Spring 2026.