Christopher Batten

Current Teaching

ECE 2400 / ENGRD 2140 Computer Systems Programming

This course aims to provide a strong foundation in the principles,
practices, and art of computer systems programming using C and C++, the
languages of choice for system-level programmers. The course is
structured into three parts. In the first part, students will use C to
explore procedural programming (e.g., functions, conditional
statements, and iteration statements; recursion; types; pointers;
arrays; dynamic allocation); students will then apply then apply their
knowledge of C to explore basic data structures and algorithms (e.g.,
complexity analysis; concrete data types such as lists and vectors;
abstract data types such as sequences, stacks, queues, sets, and maps;
sorting algorithms). In the second part, students will transition from
C to C++ and then use C++ to explore four programming paradigms:
object-oriented programming (e.g., C++ classes and inheritance for
dynamic polymorphism), generic programming (e.g., C++ templates for
static polymorphism), functional programming (e.g., C++ functors and
lambdas), and concurrent programming (e.g., C++ threads and atomics);
students will then apply their knowledge of multi-paradigm C++ to
explore more advanced algorithms and data structures (e.g., trees, hash
tables, and graphs). In the third part, students will explore systems
programming in the UNIX environment using POSIX standard library. The
course includes a series of programming assignments for students to put
the principles they have learned into practice. Students will gain
experience with UNIX software development including command line
development tools, distributed version control, unit testing
frameworks, continuous integration, debugging tools, and performance
evaluation. In the final programming assignment, students will work in
pairs to design, implement, test, and evaluate a high-performance
handwriting recognition system which uses machine learning to
automatically classify handwritten letters.

Previous Teaching

ECE 4750 / CS 4420 Computer Architecture

This course provides a strong foundation for understanding modern
computer system architecture and for designing future systems. The
course is structured around the three primary building blocks of
general-purpose computing systems: processors, memories, and networks.
The first half of the course focuses on the fundamentals of each
building block and will enable students to understand how these three
building blocks can be integrated to build a simple multicore system.
Topics include processor microcoding and pipelining; single-core and
multi-core cache microarchitecture; and network topology, routing, and
flow control. The second half of the course delves into more advanced
techniques related to processors and memories and will enable students
to understand sophisticated, modern multicore systems. Topics include
superscalar execution, branch prediction, out-of-order execution,
register renaming, memory disambiguation, VLIW processors, vector
processors, multithreaded processors, address translation and
protection, virtual memory, synchronization, consistency, coherence, and
advanced cache microarchitecture. Students will learn how to evaluate
design decisions in the context of past, current, and future application
requirements and technology constraints. This course includes a
significant project decomposed into five lab assignments. Throughout the
semester, students will gradually design, implement, test, and evaluate
a simple multicore system capable of running real parallel applications
at the register-transfer level.

ECE 5970 Special Topics: Chip-Level Interconnection Networks

Today's embedded, network, graphics, and server processors already
contain tens to hundreds of cores integrated onto just a few chips, and
this number will surely increase with future scaling. Chip-level
interconnection networks, which connect cores on the same or different
chips to each other and to main memory, are becoming a critical design
component in terms of performance, power consumption, and programmer
productivity. This course explores the underlying principles and the
practical implementation issues for such networks. Topics include
network topology, routing algorithms, flow-control strategies, router
microarchitecture, performance analysis, and emerging physical
technology issues. The course includes a mix of lectures and
student-led discussion of both classic and modern research papers in
the field. In the latter portion of the course, students work in small
groups to design, implement, and evaluate an interesting research idea
related to chip-level interconnection networks.