Current Teaching

ECE 2400 / ENGRD 2140 Computer Systems Programming

Fall 2017, 2018 (Course Webpage)

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.

ECE 5745 Complex Digital ASIC Design

Spring 2012–2013, 2015–2017 (Course Webpage)

This course focuses on the principles and practices involved in the design, implementation, testing, and evaluation of complex standard-cell ASIC chips using automated state-of-the-art CAD tools. Topics include hardware description languages; CMOS logic, state, and interconnect fundamentals; chip design methodologies; automated cell-based design; CAD algorithms; details of accurately modeling ASIC delay, energy, and area; robustness issues; testing, verification, and debugging; power distribution and clocking; packaging and I/O. The course includes a six-week open-ended project where small groups of students design, implement, test, and evaluate an interesting technique in computer architecture using functional-, microarchitectural-, register-transfer-, and layout-level modeling.

ECE 4750 / CS 4420 Computer Architecture

Fall 2010–2016 (Course Webpage)

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

Spring 2010 (Course Webpage)

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.