Vikram S. Adve

Donald B. Gillies Professor | Computer Science Department|University of Illinois at Urbana-Champaign

CS 598LCE: Languages and Compilers for Intelligent Edge Computing


Vikram Adve, Professor
Computer Science Department and Center for Digital Agriculture
4305 Siebel Center
University of Illinois at Urbana-Champaign


TIME: Tue/Thu 11-12:15pm (regular UIUC scheduled time)

CLASSROOM: 1111 Siebel Center (class is virtual on Zoom for Jan. 18 and Jan. 20)

ZOOM LINK (when class is virtual):

UIUC Senate Academic Calendar (official holidays):


The reading list for the class is available at


Information about the goals and requirements for the semester-long programming project are described at the bottom, below.  Students are free to pick their own project topics, subject to a few constraints, described below.  Some possible project ideas are available at:


Many important application domains require increasingly powerful computing capabilities at the “edge of the network,” near the sensors, displays and actuators that interact with the physical and human world. Examples of such application domains include real-time video analytics, autonomous vehicles, robots and drones, digital agriculture, AR/VR, and “smart systems” in numerous areas such as manufacturing, civil engineering, transportation, retail, home automation, and others. Increasingly, these applications must use advanced machine learning techniques for inference and (in some cases) learning, within a broader context of rich data-driven applications.

Today, these applications are being developed at a rapid rate, using dozens of traditional programming paradigms, languages, frameworks, systems and tools, and this pace of development is far outstripping research advances that can deliver better designed and more principled solutions. In short, the field of edge computing is wide open for innovation in the programming languages, compilers and tools that can enable efficient, secure and reliable applications. The frenetic pace of development poses major challenges; for example, models and algorithmic techniques used in computer vision, NLP, image processing, and recommender systems are evolving so rapidly that system design – both software and hardware – faces a rapidly moving target that can render solutions obsolete before they have time to become widely adopted and economically viable. If there is a silver lining, it is that there is only limited legacy code that would restrict innovation – new languages and programming tools can be deployed and adopted rapidly, as solutions like PyTorch, TensorFlow and Halide have demonstrated to a limited extent for machine learning and image processing.

A second major challenge is that edge applications require powerful computing and communication capabilities under tight constraints on compute capacity, memory size, energy, power, weight, and heat dissipation. General-purpose processing is far from sufficient to meet these demands, and the end of Dennard scaling makes this bottleneck more acute and urgent. Heterogeneous computing with specialized accelerators, usually packaged as System-on-Chip (SoC) application processors, are critical to deliver the requisite computing capabilities. Unfortunately, these heterogeneous systems are highly challenging to program. The underlying hardware usually has diverse programming interfaces (both languages and instruction sets), differing forms of parallelism, different memory architectures, and even diverse, mutually incompatible programming tools that prevent developing unified applications that can use all components flexibly. Today’s applications that want to benefit from the accelerators are forced to use separate languages, inflexible communication and scheduling mechanisms, inefficient data movement methods, and highly non-portable source code as well as object code that makes code reuse and software evolution extremely expensive and challenging. There is a profound need for more flexible, efficient and portable programming models – including languages, compilers, and tools – for edge computing applications.

An important opportunity, which brings its own programming challenges, is that many edge applications can achieve their high-level quality goals, while relaxing the accuracy, precision, or other metrics for internal components. For example, we have shown that a mobile robot using visual-guided perception for autonomous navigation can tolerate slightly reduced accuracy for neural network results while maintaining crash-free navigation goals. As another class of examples, video monitoring applications (identifying individuals in a scene, recognizing crop disease, or detecting anomalies in a construction activity) may be able to achieve acceptable application-level accuracy goals while relaxing signal-to-noise ratios (SNR) in image processing filters, or adapting frame rates in the entire analysis pipeline based on scene activity or battery power, or reducing neural network inference accuracy. Exploiting such opportunities poses significant challenges, including designing and calibrating relaxation or “approximation” methods, evaluating their impact on overall application quality goals, and selecting and tuning combinations of approximations for individual and multiple components to maximize performance (and/or minimize energy) while preserving application quality goals. This area of system design is broadly called “Approximate Computing” and is becoming increasingly important as edge applications become more ambitious and powerful, on resource-constrained systems.


  • Example Application Classes
    • Real-time video analytics; edge machine learning; AR/VR/XR; Autonomous vehicles; Mobile robots and drones
  • Edge Computing Architectures
    • General-purpose low-power processors
    • Programmable domain-specific accelerators
    • Custom accelerators
    • System-on-Chip Processors
  • Programming Languages for Edge Computing (exact list subject to change)
    • IoT Languages (survey); CSPOT
    • Image processing DSLs: Halide
    • Machine Learning DSLs: TensorFlow / TF Lite, Relay
    • GPU programming languages: CUDA, Quasar
    • Hardware design languages: Spatial, HeteroCL
  • Compilers for Heterogeneous Parallel Systems and Edge Computing (exact list subject to change)
    • Heterogeneous system compilers: SoC-C, HPVM, TinyDB, Dandelion
    • ML compilers: TVM, MLIR, TASO, automated kernel synthesis
    • DSL compilers and infrastructures: Delite, Halide,
  • Approximate Computing for Edge Applications
    • Application-level quality metrics
    • Approximation techniques
    • Language support
    • Approximation tuning systems


The broad goal of this class is to learn about and understand – through both literature review and a hands-on programming project – the current state-of-the-art of programming edge computing applications. Because of the diversity of the field and the limited time, we will focus on selected classes of computations that are becoming increasingly important in edge applications and yet are some of the most computationally challenging, e.g., computer vision, speech processing, machine learning and inference, signal processing, SLAM, etc. We will first briefly discuss concrete applications or application domains to understand their computational and programming requirements (~1.5 weeks). The next part of the class (~3 weeks) will be a discussion of the state-of-the-art of hardware support for edge computing. The main focus of the class (~9 weeks) will then be on the languages, compilers and tools, and approximate computing techniques used for these applications, spanning both production systems and research. The last ~1 week of the class will be devoted to project presentations.

Each student will be expected to present and lead the discussion for several papers during the course of the semester. The course grade will be based on the paper presentations and a programming project. The programming project will be in teams of 2-3 students, and should explore an open research question, to the extent feasible in one semester, and not a project you are doing already for your research (but can be related to it). The project must be related to the topic of the class: languages and/or compilers for edge computing. Within these constraints, students are free to choose the problem, system(s), and programming tools they wish. You will need to prepare a brief project proposal, a mid-term progress report, and a final project presentation. All members of a team will be given the same grade, without exception. For Spring 2022, this class will be held in person, except that the first two lectures (Jan. 18 & 20) will be synchronous (live) online, using Zoom. Class discussions will use a Slack channel.