Teach performance

OpenCilk is an important component of a portfolio of software technologies and techniques that allow engineers to develop fast code for applications that run on commodity and cloud multicore computers. As the economics of the semiconductor industry, coupled with the end of many years of Moore's-Law and Dennard scaling, spell the end of a long run of historical performance gains due to technology improvements alone, the importance of performance engineering to continue to improve performance is growing in importance. Continued performance growth is vital for continued advances in vital computing domains such as machine learning, simulation of physical phenomena, and computer security. Indeed, this need has made performance engineering a national strategic priority.

Traditional computer science and engineering curricula feature courses that concentrate on one particular technology, such as compilers, operating systems, algorithms, or machine learning. In contrast, performance engineering brings together technologies and techniques that span many layers of a computing system, including architecture, compilers, programming languages, parallel computing theory and implementation, and algorithms.

OpenCilk is well-positioned as an important component to help academics teach performance engineering because of its simple language, small codebase, and mathematically provable guarantees of good performance.

The performance engineering community is eager to attract faculty to join this community and teach performance engineering material in new or existing courses. We wish to make adoption of this material as easy as possible and hope faculty with interest in this topic will help grow our community and build and extend its relevant course material.

Topics Covered

At MIT, Performance Engineering of Software Systems is an upper-division undergraduate course with prereqs of introductory computer architecture, algorithms, and programming courses. Other faculty have adapted this material as an introductory graduate course. The class uses the C language with OpenCilk task-parallel extensions. Recent Performance Engineering of Software Systems offerings, which provide free and open course material for adoption, have featured roughly 20 lectures on the following topics:

  • Intro and Matrix Multiplication
  • Bentley Rules
  • Bit Hacks
  • Architecture and Vectorization
  • C to Assembly
  • Compilers
  • Multicore Programming
  • Races and Parallelism
  • Analysis of Parallel Algorithms
  • Measurement and Timing
  • Cilk Runtime System
  • Caching and Cache Efficient Algorithms
  • Cache Oblivious Algorithms
  • Synchronization
  • Speculative Parallelism


MIT's course has a significant homework/project component. Enabling students to achieve high performance on project submissions is a significant goal of the course. MIT typically uses servers from commercial cloud providers (historically AWS) to accept project submissions and measure performance.

Recent projects have included rotating an image, parallelization of a physical simulation, and memory management. The traditional MIT capstone project is a bot that plays one side of a 2-player game, where optimized bot performance is a necessity for a competitive submission.

What can we provide?

Upon request, we can provide:

  • PowerPoint source for slides
  • Video recordings of a past course offering's lectures
  • LaTeX source for homework and projects from a past course offering
  • Reference code for homeworks and projects
  • A library of past quiz and exam questions